@kaiko.io/rescript-deser 3.1.3 → 4.0.0-alpha.1

package/lib/js/src/JSON.js

@@ -12,42 +12,54 @@ var FieldValue = {};
 
 var $$TypeError = /* @__PURE__ */Caml_exceptions.create("JSON.TypeError");
 
-function usingString(f, value) {
-  return Curry._1(f, value);
+function usingString(f) {
+  return function (value) {
+    return f(value);
+  };
 }
 
-function usingInt(f, value) {
-  return Curry._1(f, value);
+function usingInt(f) {
+  return function (value) {
+    return f(value);
+  };
 }
 
-function usingFloat(f, value) {
-  return Curry._1(f, value);
+function usingFloat(f) {
+  return function (value) {
+    return f(value);
+  };
 }
 
-function usingBoolean(f, value) {
-  return Curry._1(f, value);
+function usingBoolean(f) {
+  return function (value) {
+    return f(value);
+  };
 }
 
-function usingArray(f, value) {
-  return Curry._1(f, value);
+function usingArray(f) {
+  return function (value) {
+    return f(value);
+  };
 }
 
-function usingObject(f, value) {
-  return Curry._1(f, value);
+function usingObject(f) {
+  return function (value) {
+    return f(value);
+  };
 }
 
 function variadicInt(hint, fromJs) {
   return {
-          TAG: /* Morphism */10,
-          _0: /* Int */2,
-          _1: (function (param) {
-              var internalValue = Curry._1(fromJs, param);
+          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(param) + ") not a valid value here. Hint: " + hint + "",
+                    _1: "This Int(" + String(value) + ") not a valid value here. Hint: " + hint,
                     Error: new Error()
                   };
             })
@@ -56,16 +68,16 @@ function variadicInt(hint, fromJs) {
 
 function variadicString(hint, fromJs) {
   return {
-          TAG: /* Morphism */10,
-          _0: /* String */1,
-          _1: (function (param) {
-              var internalValue = Curry._1(fromJs, param);
+          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(\"" + param + "\") not a valid value here. Hint: " + hint + "",
+                    _1: "This String(\"" + value + "\") not a valid value here. Hint: " + hint,
                     Error: new Error()
                   };
             })
@@ -73,50 +85,50 @@ function variadicString(hint, fromJs) {
 }
 
 function toString(type_) {
-  if (typeof type_ === "number") {
+  if (typeof type_ !== "object") {
     switch (type_) {
-      case /* Any */0 :
+      case "Any" :
           return "Any";
-      case /* String */1 :
+      case "String" :
           return "String";
-      case /* Int */2 :
+      case "Int" :
           return "Integer";
-      case /* Float */3 :
+      case "Float" :
           return "Float";
-      case /* Boolean */4 :
+      case "Boolean" :
           return "Boolean";
-      case /* Date */5 :
-      case /* Datetime */6 :
+      case "Date" :
+      case "Datetime" :
           return "Date";
-      case /* Self */7 :
+      case "Self" :
           return "Self (recursive)";
       
     }
   } else {
-    switch (type_.TAG | 0) {
-      case /* Literal */0 :
-          return "Literal: " + type_._0 + "";
-      case /* Array */1 :
+    switch (type_.TAG) {
+      case "Literal" :
+          return "Literal: " + type_._0;
+      case "Array" :
           return "Array of " + toString(type_._0);
-      case /* Tuple */2 :
+      case "Tuple" :
           return "Tuple of (" + Curry._2(Prelude.$$Array.map, type_._0, toString).join(", ") + ")";
-      case /* Object */3 :
+      case "Object" :
           var desc = Curry._2(Prelude.$$Array.map, type_._0, (function (param) {
-                    return "" + param[0] + ": " + toString(param[1]) + "";
+                    return param[0] + ": " + toString(param[1]);
                   })).join(", ");
           return "Object of {" + desc + "}";
-      case /* Optional */4 :
-      case /* OptionalWithDefault */5 :
+      case "Optional" :
+      case "OptionalWithDefault" :
           return "Null of " + toString(type_._0);
-      case /* Mapping */6 :
-          return "Mapping of " + toString(type_._0) + "";
-      case /* Deserializer */7 :
+      case "Mapping" :
+          return "Mapping of " + toString(type_._0);
+      case "Deserializer" :
           return type_._0.name;
-      case /* Collection */8 :
+      case "Collection" :
           return "Collection of " + type_._0.name;
-      case /* DefaultWhenInvalid */9 :
-          return "Protected " + toString(type_._0) + "";
-      case /* Morphism */10 :
+      case "DefaultWhenInvalid" :
+          return "Protected " + toString(type_._0);
+      case "Morphism" :
           return toString(type_._0) + " to apply a morphism";
       
     }
@@ -124,25 +136,25 @@ function toString(type_) {
 }
 
 function _taggedToString(tagged) {
-  if (typeof tagged === "number") {
+  if (typeof tagged !== "object") {
     switch (tagged) {
-      case /* JSONFalse */0 :
+      case "JSONFalse" :
           return "Boolean(false)";
-      case /* JSONTrue */1 :
+      case "JSONTrue" :
           return "Boolean(true)";
-      case /* JSONNull */2 :
+      case "JSONNull" :
           return "Null";
       
     }
   } else {
-    switch (tagged.TAG | 0) {
-      case /* JSONString */0 :
+    switch (tagged.TAG) {
+      case "JSONString" :
           return "String(\"" + tagged._0 + "\")";
-      case /* JSONNumber */1 :
+      case "JSONNumber" :
           return "Number(" + String(tagged._0) + ")";
-      case /* JSONObject */2 :
+      case "JSONObject" :
           return "Object(" + Prelude.$$default(JSON.stringify(tagged._0), "...") + ")";
-      case /* JSONArray */3 :
+      case "JSONArray" :
           return "Array(" + Prelude.$$default(JSON.stringify(tagged._0), "...") + ")";
       
     }
@@ -152,14 +164,14 @@ function _taggedToString(tagged) {
 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);
+    return fromUntagged(value, shape, self);
   }
-  if (typeof shape !== "number") {
-    switch (shape.TAG | 0) {
-      case /* OptionalWithDefault */5 :
+  if (typeof shape === "object") {
+    switch (shape.TAG) {
+      case "OptionalWithDefault" :
           return shape._1;
-      case /* Optional */4 :
-      case /* DefaultWhenInvalid */9 :
+      case "Optional" :
+      case "DefaultWhenInvalid" :
           return fromUntagged(null, shape, self);
       default:
         
@@ -179,66 +191,64 @@ function fromUntagged(untagged, _shape, self) {
     var exit = 0;
     var s;
     var f;
-    if (typeof shape === "number") {
+    if (typeof shape !== "object") {
       switch (shape) {
-        case /* Any */0 :
+        case "Any" :
             return untagged;
-        case /* String */1 :
-            if (typeof match === "number") {
+        case "String" :
+            if (typeof match !== "object") {
               exit = 1;
             } else {
-              if (match.TAG === /* JSONString */0) {
+              if (match.TAG === "JSONString") {
                 return match._0;
               }
               exit = 1;
             }
             break;
-        case /* Int */2 :
-            if (typeof match === "number") {
+        case "Int" :
+            if (typeof match !== "object") {
               exit = 1;
             } else {
-              if (match.TAG === /* JSONNumber */1) {
+              if (match.TAG === "JSONNumber") {
                 return match._0 | 0;
               }
               exit = 1;
             }
             break;
-        case /* Float */3 :
-            if (typeof match === "number") {
+        case "Float" :
+            if (typeof match !== "object") {
               exit = 1;
             } else {
-              if (match.TAG === /* JSONNumber */1) {
+              if (match.TAG === "JSONNumber") {
                 return match._0;
               }
               exit = 1;
             }
             break;
-        case /* Boolean */4 :
-            if (typeof match === "number") {
+        case "Boolean" :
+            if (typeof match !== "object") {
               switch (match) {
-                case /* JSONFalse */0 :
+                case "JSONFalse" :
                     return false;
-                case /* JSONTrue */1 :
+                case "JSONTrue" :
                     return true;
-                case /* JSONNull */2 :
-                    exit = 1;
-                    break;
-                
+                default:
+                  exit = 1;
               }
             } else {
               exit = 1;
             }
             break;
-        case /* Date */5 :
-            if (typeof match === "number") {
+        case "Date" :
+            if (typeof match !== "object") {
               exit = 1;
             } else {
-              switch (match.TAG | 0) {
-                case /* JSONString */0 :
+              switch (match.TAG) {
+                case "JSONString" :
                     s = match._0;
                     exit = 2;
                     break;
-                case /* JSONNumber */1 :
+                case "JSONNumber" :
                     f = match._0;
                     exit = 3;
                     break;
@@ -247,16 +257,16 @@ function fromUntagged(untagged, _shape, self) {
               }
             }
             break;
-        case /* Datetime */6 :
-            if (typeof match === "number") {
+        case "Datetime" :
+            if (typeof match !== "object") {
               exit = 1;
             } else {
-              switch (match.TAG | 0) {
-                case /* JSONString */0 :
+              switch (match.TAG) {
+                case "JSONString" :
                     s = match._0;
                     exit = 2;
                     break;
-                case /* JSONNumber */1 :
+                case "JSONNumber" :
                     f = match._0;
                     exit = 3;
                     break;
@@ -265,18 +275,18 @@ function fromUntagged(untagged, _shape, self) {
               }
             }
             break;
-        case /* Self */7 :
+        case "Self" :
             _shape = self;
             continue ;
         
       }
     } else {
-      switch (shape.TAG | 0) {
-        case /* Literal */0 :
-            if (typeof match === "number") {
+      switch (shape.TAG) {
+        case "Literal" :
+            if (typeof match !== "object") {
               exit = 1;
             } else {
-              if (match.TAG === /* JSONString */0) {
+              if (match.TAG === "JSONString") {
                 var text = match._0;
                 var expected = shape._0;
                 if (text === expected) {
@@ -284,18 +294,18 @@ function fromUntagged(untagged, _shape, self) {
                 }
                 throw {
                       RE_EXN_ID: $$TypeError,
-                      _1: "Expecting literal " + expected + ", got " + text + "",
+                      _1: "Expecting literal " + expected + ", got " + text,
                       Error: new Error()
                     };
               }
               exit = 1;
             }
             break;
-        case /* Array */1 :
-            if (typeof match === "number") {
+        case "Array" :
+            if (typeof match !== "object") {
               exit = 1;
             } else {
-              if (match.TAG === /* JSONArray */3) {
+              if (match.TAG === "JSONArray") {
                 var shape$1 = shape._0;
                 return Curry._2(Prelude.$$Array.map, match._0, (function(shape$1){
                           return function (item) {
@@ -306,11 +316,11 @@ function fromUntagged(untagged, _shape, self) {
               exit = 1;
             }
             break;
-        case /* Tuple */2 :
-            if (typeof match === "number") {
+        case "Tuple" :
+            if (typeof match !== "object") {
               exit = 1;
             } else {
-              if (match.TAG === /* JSONArray */3) {
+              if (match.TAG === "JSONArray") {
                 var items = match._0;
                 var bases = shape._0;
                 var lenbases = bases.length;
@@ -322,18 +332,18 @@ function fromUntagged(untagged, _shape, self) {
                 }
                 throw {
                       RE_EXN_ID: $$TypeError,
-                      _1: "Expecting " + String(lenbases) + " items, got " + String(lenitems) + "",
+                      _1: "Expecting " + String(lenbases) + " items, got " + String(lenitems),
                       Error: new Error()
                     };
               }
               exit = 1;
             }
             break;
-        case /* Object */3 :
-            if (typeof match === "number") {
+        case "Object" :
+            if (typeof match !== "object") {
               exit = 1;
             } else {
-              if (match.TAG === /* JSONObject */2) {
+              if (match.TAG === "JSONObject") {
                 var values = match._0;
                 return Curry._1(Prelude.Dict.fromArray, Curry._2(Prelude.$$Array.map, shape._0, (function(values){
                               return function (param) {
@@ -347,7 +357,7 @@ function fromUntagged(untagged, _shape, self) {
                                   if (msg.RE_EXN_ID === $$TypeError) {
                                     throw {
                                           RE_EXN_ID: $$TypeError,
-                                          _1: "Field \"" + field + "\": " + msg._1 + "",
+                                          _1: "Field \"" + field + "\": " + msg._1,
                                           Error: new Error()
                                         };
                                   }
@@ -363,33 +373,35 @@ function fromUntagged(untagged, _shape, self) {
               exit = 1;
             }
             break;
-        case /* Optional */4 :
+        case "Optional" :
             var shape$2 = shape._0;
-            if (typeof match === "number") {
-              if (match >= 2) {
+            if (typeof match !== "object") {
+              if (match === "JSONNull") {
                 return undefined;
               }
               _shape = shape$2;
               continue ;
+            } else {
+              _shape = shape$2;
+              continue ;
             }
-            _shape = shape$2;
-            continue ;
-        case /* OptionalWithDefault */5 :
+        case "OptionalWithDefault" :
             var shape$3 = shape._0;
-            if (typeof match === "number") {
-              if (match >= 2) {
+            if (typeof match !== "object") {
+              if (match === "JSONNull") {
                 return shape._1;
               }
               _shape = shape$3;
               continue ;
+            } else {
+              _shape = shape$3;
+              continue ;
             }
-            _shape = shape$3;
-            continue ;
-        case /* Mapping */6 :
-            if (typeof match === "number") {
+        case "Mapping" :
+            if (typeof match !== "object") {
               exit = 1;
             } else {
-              if (match.TAG === /* JSONObject */2) {
+              if (match.TAG === "JSONObject") {
                 var f$1 = shape._0;
                 return Prelude.Dict.mapValues(match._0, (function(f$1){
                           return function (v) {
@@ -400,9 +412,9 @@ function fromUntagged(untagged, _shape, self) {
               exit = 1;
             }
             break;
-        case /* Deserializer */7 :
-            var res = Curry._1(shape._0.fromJSON, untagged);
-            if (res.TAG === /* Ok */0) {
+        case "Deserializer" :
+            var res = shape._0.fromJSON(untagged);
+            if (res.TAG === "Ok") {
               return res._0;
             }
             throw {
@@ -410,11 +422,11 @@ function fromUntagged(untagged, _shape, self) {
                   _1: res._0,
                   Error: new Error()
                 };
-        case /* Collection */8 :
-            if (typeof match === "number") {
+        case "Collection" :
+            if (typeof match !== "object") {
               exit = 1;
             } else {
-              if (match.TAG === /* JSONArray */3) {
+              if (match.TAG === "JSONArray") {
                 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;
                             }));
@@ -422,7 +434,7 @@ function fromUntagged(untagged, _shape, self) {
               exit = 1;
             }
             break;
-        case /* DefaultWhenInvalid */9 :
+        case "DefaultWhenInvalid" :
             try {
               return fromUntagged(untagged, shape._0, self);
             }
@@ -434,8 +446,8 @@ function fromUntagged(untagged, _shape, self) {
               }
               throw msg;
             }
-        case /* Morphism */10 :
-            return Curry._1(shape._1, fromUntagged(untagged, shape._0, self));
+        case "Morphism" :
+            return shape._1(fromUntagged(untagged, shape._0, self));
         
       }
     }
@@ -451,7 +463,7 @@ function fromUntagged(untagged, _shape, self) {
           if (Number.isNaN(r.getDate())) {
             throw {
                   RE_EXN_ID: $$TypeError,
-                  _1: "Invalid date " + s + "",
+                  _1: "Invalid date " + s,
                   Error: new Error()
                 };
           }
@@ -461,7 +473,7 @@ function fromUntagged(untagged, _shape, self) {
           if (Number.isNaN(r$1.getDate())) {
             throw {
                   RE_EXN_ID: $$TypeError,
-                  _1: "Invalid date " + f.toString() + "",
+                  _1: "Invalid date " + f.toString(),
                   Error: new Error()
                 };
           }
@@ -476,74 +488,80 @@ function checkFieldsSanity(name, _fields, _optional) {
     var optional = _optional;
     var fields = _fields;
     var exit = 0;
-    if (typeof fields === "number") {
+    if (typeof fields !== "object") {
       switch (fields) {
-        case /* Any */0 :
-        case /* Boolean */4 :
-        case /* Date */5 :
-        case /* Datetime */6 :
+        case "Any" :
+        case "Boolean" :
+        case "Date" :
+        case "Datetime" :
             return {
-                    TAG: /* Ok */0,
+                    TAG: "Ok",
                     _0: undefined
                   };
-        case /* Self */7 :
+        case "Self" :
             if (optional) {
               return {
-                      TAG: /* Ok */0,
+                      TAG: "Ok",
                       _0: undefined
                     };
             } else {
               return {
-                      TAG: /* Error */1,
-                      _0: "" + name + ": Trivial infinite recursion 'let fields = Self'"
+                      TAG: "Error",
+                      _0: name + ": Trivial infinite recursion 'let fields = Self'"
                     };
             }
         default:
           return {
-                  TAG: /* Ok */0,
+                  TAG: "Ok",
                   _0: undefined
                 };
       }
     } else {
-      switch (fields.TAG | 0) {
-        case /* Tuple */2 :
+      switch (fields.TAG) {
+        case "Tuple" :
             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);
+                              return function (index, field) {
+                                return function () {
+                                  return checkFieldsSanity(name + "[" + String(index) + "]", field, optional);
+                                };
                               }
                               }(optional)))), (function (param) {
                           
                         }));
-        case /* Object */3 :
+        case "Object" :
             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);
+                              return function (param) {
+                                var field = param[1];
+                                var fieldName = param[0];
+                                return function () {
+                                  return checkFieldsSanity(name + "::" + fieldName, field, optional);
+                                };
                               }
                               }(optional)))), (function (param) {
                           
                         }));
-        case /* Array */1 :
-        case /* Mapping */6 :
+        case "Array" :
+        case "Mapping" :
             _optional = true;
             _fields = fields._0;
             continue ;
-        case /* Deserializer */7 :
-        case /* Collection */8 :
+        case "Deserializer" :
+        case "Collection" :
             exit = 2;
             break;
-        case /* Optional */4 :
-        case /* OptionalWithDefault */5 :
-        case /* DefaultWhenInvalid */9 :
+        case "Optional" :
+        case "OptionalWithDefault" :
+        case "DefaultWhenInvalid" :
             exit = 1;
             break;
-        case /* Morphism */10 :
+        case "Morphism" :
             return {
-                    TAG: /* Ok */0,
+                    TAG: "Ok",
                     _0: undefined
                   };
         default:
           return {
-                  TAG: /* Ok */0,
+                  TAG: "Ok",
                   _0: undefined
                 };
       }
@@ -554,16 +572,16 @@ function checkFieldsSanity(name, _fields, _optional) {
           _fields = fields._0;
           continue ;
       case 2 :
-          var msg = Curry._1(fields._0.checkFieldsSanity, undefined);
-          if (msg.TAG === /* Ok */0) {
+          var msg = fields._0.checkFieldsSanity(undefined);
+          if (msg.TAG === "Ok") {
             return {
-                    TAG: /* Ok */0,
+                    TAG: "Ok",
                     _0: undefined
                   };
           } else {
             return {
-                    TAG: /* Error */1,
-                    _0: "" + name + "/ " + msg._0 + ""
+                    TAG: "Error",
+                    _0: name + "/ " + msg._0
                   };
           }
       
@@ -589,8 +607,8 @@ var Field = {
 
 function MakeDeserializer(S) {
   var fields = S.fields;
-  var name = "Deserializer " + "JSON" + ", " + "File \"JSON.res\", line 321, characters 39-47" + "";
-  var checkFieldsSanity$1 = function (param) {
+  var name = "Deserializer " + "JSON" + ", " + "File \"JSON.res\", line 319, characters 39-47";
+  var checkFieldsSanity$1 = function () {
     return checkFieldsSanity(name, fields, false);
   };
   var fromJSON = function (json) {
@@ -602,14 +620,14 @@ function MakeDeserializer(S) {
       var e = Caml_js_exceptions.internalToOCamlException(raw_e);
       if (e.RE_EXN_ID === $$TypeError) {
         return {
-                TAG: /* Error */1,
+                TAG: "Error",
                 _0: e._1
               };
       }
       throw e;
     }
     return {
-            TAG: /* Ok */0,
+            TAG: "Ok",
             _0: res
           };
   };