@kaiko.io/rescript-deser 3.1.1 → 3.1.2

package/lib/bs/.bsdeps

@@ -1,7 +1,7 @@
 10.1.4
 /home/manu/src/kaiko/rescript-deser
 0
-bsconfig.json	0x1.928a985db325ep+30
+bsconfig.json	0x1.928aa9540909p+30
 tests	0x1.928a985db325ep+30
 src/	0x1.928a966f225d1p+30
 ===

package/lib/bs/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1688380979802)
-#Done(1688380979840)
+#Start(1688382096677)
+#Done(1688382096677)

package/lib/bs/.ninja_log

@@ -1,93 +1,28 @@
 # ninja log v6
-0	8	1688379247615623387	tests/basic.test.ast	b18ba9a9379ce270
-1	9	1688379247615623387	src/JSON.ast	23930881e232c07e
-8	10	1688379247618956759	tests/basic.test.d	e38380efe2655d28
-9	11	1688379247618956759	src/JSON.d	d00ba87460d947fd
-11	29	1688379247635623618	src/JSON.cmj	67397b051f42aeaa
-11	29	1688379247635623618	src/JSON.cmi	67397b051f42aeaa
-11	29	1688379247635623618	../js/src/JSON.js	67397b051f42aeaa
-29	42	1688379247648957107	tests/basic.test.cmj	264790990402e165
-29	42	1688379247648957107	tests/basic.test.cmi	264790990402e165
-29	42	1688379247648957107	../js/tests/basic.test.js	264790990402e165
-1	4	1688379247615623387	src/JSON.d	fc2c0e0c4fe5285f
-1	4	1688379866579377605	tests/basic.test.d	596a67a62e5625fe
-0	8	1688379866582710976	tests/Vitest.ast	28d80820c52df4e6
-8	12	1688379866586044348	tests/Vitest.d	284003306f693a77
-12	20	1688379866592711090	tests/Vitest.cmj	99911ce485217725
-12	20	1688379866592711090	tests/Vitest.cmi	99911ce485217725
-12	20	1688379866592711090	../js/tests/Vitest.js	99911ce485217725
-0	12	1688379868009393830	tests/Vitest.ast	28d80820c52df4e6
-12	15	1688379868009393830	tests/Vitest.d	284003306f693a77
-15	43	1688379868042727542	tests/Vitest.cmj	99911ce485217725
-15	43	1688379868042727542	tests/Vitest.cmi	99911ce485217725
-15	43	1688379868042727542	../js/tests/Vitest.js	99911ce485217725
-43	57	1688379868039394170	tests/basic.test.cmj	264790990402e165
-43	57	1688379868039394170	tests/basic.test.cmi	264790990402e165
-43	57	1688379868039394170	../js/tests/basic.test.js	264790990402e165
-0	34	1688379868009393830	tests/Vitest.cmj	5cdaa44fe168d6d
-0	34	1688379868009393830	tests/Vitest.cmi	5cdaa44fe168d6d
-0	34	1688379868009393830	../js/tests/Vitest.js	5cdaa44fe168d6d
-0	18	1688379247618956759	src/JSON.cmj	fa5cf520a8be3344
-0	18	1688379247618956759	src/JSON.cmi	fa5cf520a8be3344
-0	18	1688379247618956759	../js/src/JSON.js	fa5cf520a8be3344
-0	30	1688379868009393830	tests/Vitest.cmj	cc2f06b9e262dacc
-0	30	1688379868009393830	tests/Vitest.cmi	cc2f06b9e262dacc
-0	30	1688379868009393830	../js/tests/Vitest.js	cc2f06b9e262dacc
-30	42	1688379891392992407	tests/basic.test.cmj	68fbf486ceda534b
-30	42	1688379891392992407	tests/basic.test.cmi	68fbf486ceda534b
-30	42	1688379891392992407	../js/tests/basic.test.js	68fbf486ceda534b
-0	17	1688379247618956759	src/JSON.cmj	e156d0c178c482e3
-0	17	1688379247618956759	src/JSON.cmi	e156d0c178c482e3
-0	17	1688379247618956759	../js/src/JSON.js	e156d0c178c482e3
-0	29	1688379868009393830	tests/Vitest.cmj	2125bb8631fd6b6f
-0	29	1688379868009393830	tests/Vitest.cmi	2125bb8631fd6b6f
-0	29	1688379868009393830	../js/tests/Vitest.js	2125bb8631fd6b6f
-29	42	1688379891392992407	tests/basic.test.cmj	796dce8c08df8f5f
-29	42	1688379891392992407	tests/basic.test.cmi	796dce8c08df8f5f
-29	42	1688379891392992407	../js/tests/basic.test.js	796dce8c08df8f5f
-0	3	1688379247615623387	src/JSON.d	d00ba87460d947fd
-0	3	1688379935600160219	tests/basic.test.d	e38380efe2655d28
-3	15	1688379935600160219	tests/basic.test.cmj	796dce8c08df8f5f
-3	15	1688379935600160219	tests/basic.test.cmi	796dce8c08df8f5f
-3	15	1688379935600160219	../js/tests/basic.test.js	796dce8c08df8f5f
-0	3	1688379946993622648	tests/basic.test.d	6f90ecc99fcd468a
-1	10	1688379947003622761	src/Deser.ast	cd0b25377a211e66
-10	13	1688379947006956132	src/Deser.d	a9b5860301395adf
-13	31	1688379947023622987	src/Deser.cmj	5c89bf2838f6ce97
-13	31	1688379947023622987	src/Deser.cmi	5c89bf2838f6ce97
-13	31	1688379947023622987	../js/src/Deser.js	5c89bf2838f6ce97
-0	12	1688379977457301032	tests/basic.test.ast	b18ba9a9379ce270
-12	15	1688379977460634403	tests/basic.test.d	6f90ecc99fcd468a
-0	10	1688379985814062321	tests/basic.test.ast	b18ba9a9379ce270
-10	13	1688379985814062321	tests/basic.test.d	6f90ecc99fcd468a
-0	14	1688380005404284107	tests/basic.test.ast	b18ba9a9379ce270
-14	17	1688380005404284107	tests/basic.test.d	6f90ecc99fcd468a
-17	29	1688380005404284107	tests/basic.test.cmj	796dce8c08df8f5f
-17	29	1688380005404284107	tests/basic.test.cmi	796dce8c08df8f5f
-17	29	1688380005404284107	../js/tests/basic.test.js	796dce8c08df8f5f
-0	3	1688380455412698631	tests/basic.test.d	e38380efe2655d28
-0	10	1688380455419365372	src/JSON.ast	23930881e232c07e
-10	13	1688380455422698743	src/JSON.d	d00ba87460d947fd
-13	32	1688380455442698969	src/JSON.cmj	e156d0c178c482e3
-13	32	1688380455442698969	src/JSON.cmi	e156d0c178c482e3
-13	32	1688380455442698969	../js/src/JSON.js	e156d0c178c482e3
-0	7	1688380477149610260	tests/basic.test.ast	b18ba9a9379ce270
-7	10	1688380477152943631	tests/basic.test.d	e38380efe2655d28
-10	23	1688380477152943631	tests/basic.test.cmj	796dce8c08df8f5f
-10	23	1688380477152943631	tests/basic.test.cmi	796dce8c08df8f5f
-10	23	1688380477152943631	../js/tests/basic.test.js	796dce8c08df8f5f
-0	7	1688380979805268331	tests/QUnit.ast	ae640b6aefd35348
-0	7	1688380979805268331	tests/index.ast	b5b685b3adc59946
-0	8	1688380979805268331	src/JSON.ast	23930881e232c07e
-7	9	1688380979808601702	tests/QUnit.d	4a2631c992d93ce7
-7	9	1688380979808601702	tests/index.d	5a4db9cdecd186b3
-8	10	1688380979805268331	src/JSON.d	cd2d6773c781340f
-9	18	1688380979815268443	tests/QUnit.cmj	743026e625d40f7c
-9	18	1688380979815268443	tests/QUnit.cmi	743026e625d40f7c
-9	18	1688380979815268443	../js/tests/QUnit.js	743026e625d40f7c
-10	27	1688380979805268331	src/JSON.cmj	a900e769d0db9273
-10	27	1688380979805268331	src/JSON.cmi	a900e769d0db9273
-10	27	1688380979805268331	../js/src/JSON.js	a900e769d0db9273
-27	38	1688380979835268668	tests/index.cmj	a7f18a4fafd85d7d
-27	38	1688380979835268668	tests/index.cmi	a7f18a4fafd85d7d
-27	38	1688380979835268668	../js/tests/index.js	a7f18a4fafd85d7d
+0	27	1688381837613117393	tests/QUnit.ast	ae640b6aefd35348
+0	28	1688381837613117393	tests/index.ast	b5b685b3adc59946
+0	29	1688381837613117393	src/JSON.ast	23930881e232c07e
+28	32	1688381837619784009	tests/QUnit.d	4a2631c992d93ce7
+29	32	1688381837619784009	src/JSON.d	cd2d6773c781340f
+28	33	1688381837619784009	tests/index.d	5a4db9cdecd186b3
+32	41	1688381837626450625	tests/QUnit.cmj	af48764142174424
+32	41	1688381837626450625	tests/QUnit.cmi	af48764142174424
+32	41	1688381837626450625	../es6/tests/QUnit.js	af48764142174424
+33	50	1688381837636450550	src/JSON.cmj	4715564a08207e44
+33	50	1688381837636450550	src/JSON.cmi	4715564a08207e44
+33	50	1688381837636450550	../es6/src/JSON.js	4715564a08207e44
+50	62	1688381837646450474	tests/index.cmj	afa68ed03027d968
+50	62	1688381837646450474	tests/index.cmi	afa68ed03027d968
+50	62	1688381837646450474	../es6/tests/index.js	afa68ed03027d968
+0	8	1688381837619784009	tests/QUnit.cmj	f85ad7fabdfec222
+0	8	1688381837619784009	tests/QUnit.cmi	f85ad7fabdfec222
+0	8	1688381837619784009	../es6/tests/QUnit.js	f85ad7fabdfec222
+0	8	1688381837619784009	../js/tests/QUnit.js	f85ad7fabdfec222
+0	18	1688381837619784009	src/JSON.cmj	9628ec2442bee34e
+0	18	1688381837619784009	src/JSON.cmi	9628ec2442bee34e
+0	18	1688381837619784009	../es6/src/JSON.js	9628ec2442bee34e
+0	18	1688381837619784009	../js/src/JSON.js	9628ec2442bee34e
+18	30	1688382079735404980	tests/index.cmj	a5ae0db315b2706d
+18	30	1688382079735404980	tests/index.cmi	a5ae0db315b2706d
+18	30	1688382079735404980	../es6/tests/index.js	a5ae0db315b2706d
+18	30	1688382079735404980	../js/tests/index.js	a5ae0db315b2706d

package/lib/bs/build.ninja

@@ -8,20 +8,20 @@ rule deps_dev
   restat = 1
 o tests/index.d : deps_dev tests/index.ast
 rule mij_dev
-  command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsc.exe -I tests -I src/ -I /home/manu/src/kaiko/rescript-deser/node_modules/@kaiko.io/rescript-prelude/lib/ocaml    -warn-error +8+11+26+27+33+56 -bs-package-name @kaiko.io/rescript-deser -bs-package-output commonjs:lib/js/$in_d:.js -bs-v $g_finger $i
+  command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsc.exe -I tests -I src/ -I /home/manu/src/kaiko/rescript-deser/node_modules/@kaiko.io/rescript-prelude/lib/ocaml    -warn-error +8+11+26+27+33+56 -bs-package-name @kaiko.io/rescript-deser -bs-package-output commonjs:lib/js/$in_d:.js -bs-package-output es6:lib/es6/$in_d:.js -bs-v $g_finger $i
   dyndep = 1
   restat = 1
-o tests/index.cmj tests/index.cmi ../js/tests/index.js : mij_dev tests/index.ast
+o tests/index.cmj tests/index.cmi ../es6/tests/index.js ../js/tests/index.js : mij_dev tests/index.ast
 o tests/QUnit.ast : astj ../../tests/QUnit.res
 o tests/QUnit.d : deps_dev tests/QUnit.ast
-o tests/QUnit.cmj tests/QUnit.cmi ../js/tests/QUnit.js : mij_dev tests/QUnit.ast
+o tests/QUnit.cmj tests/QUnit.cmi ../es6/tests/QUnit.js ../js/tests/QUnit.js : mij_dev tests/QUnit.ast
 o src/JSON.ast : astj ../../src/JSON.res
 rule deps
   command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsb_helper.exe -hash 84aecc33f8594375b23a1a137b057f93 $in
   restat = 1
 o src/JSON.d : deps src/JSON.ast
 rule mij
-  command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsc.exe -I src/ -I /home/manu/src/kaiko/rescript-deser/node_modules/@kaiko.io/rescript-prelude/lib/ocaml   -warn-error +8+11+26+27+33+56 -bs-package-name @kaiko.io/rescript-deser -bs-package-output commonjs:lib/js/$in_d:.js -bs-v $g_finger $i
+  command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsc.exe -I src/ -I /home/manu/src/kaiko/rescript-deser/node_modules/@kaiko.io/rescript-prelude/lib/ocaml   -warn-error +8+11+26+27+33+56 -bs-package-name @kaiko.io/rescript-deser -bs-package-output commonjs:lib/js/$in_d:.js -bs-package-output es6:lib/es6/$in_d:.js -bs-v $g_finger $i
   dyndep = 1
   restat = 1
-o src/JSON.cmj src/JSON.cmi ../js/src/JSON.js : mij src/JSON.ast
+o src/JSON.cmj src/JSON.cmi ../es6/src/JSON.js ../js/src/JSON.js : mij src/JSON.ast

package/lib/es6/src/JSON.js

@@ -0,0 +1,628 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Curry from "rescript/lib/es6/curry.js";
+import * as Js_json from "rescript/lib/es6/js_json.js";
+import * as Prelude from "@kaiko.io/rescript-prelude/lib/es6/src/Prelude.js";
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
+import * as Caml_js_exceptions from "rescript/lib/es6/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
+        };
+}
+
+export {
+  FieldValue ,
+  $$TypeError ,
+  Field ,
+  MakeDeserializer ,
+}
+/* No side effect */

package/lib/es6/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. */

package/lib/es6/tests/index.js

@@ -0,0 +1,284 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as $$JSON from "../src/JSON.js";
+import * as Curry from "rescript/lib/es6/curry.js";
+import * as Qunit from "qunit";
+import * as Prelude from "@kaiko.io/rescript-prelude/lib/es6/src/Prelude.js";
+
+var fields = {
+  TAG: /* Object */3,
+  _0: [
+    [
+      "note",
+      /* String */1
+    ],
+    [
+      "date",
+      /* Date */5
+    ],
+    [
+      "extra",
+      {
+        TAG: /* Optional */4,
+        _0: /* String */1
+      }
+    ]
+  ]
+};
+
+var Deserializer = $$JSON.MakeDeserializer({
+      fields: fields
+    });
+
+var Appointment = {
+  Deserializer: Deserializer
+};
+
+Qunit.module("Basic deserializer", (function (param) {
+        var valid = [
+          [
+            {"note": "Bicentennial doctor's appointment", "date": "2100-01-01"},
+            {
+              note: "Bicentennial doctor's appointment",
+              date: new Date("2100-01-01"),
+              extra: undefined
+            }
+          ],
+          [
+            {
+      "note": "Bicentennial doctor's appointment",
+      "date": "2100-01-01",
+      "extra": "Don't take your stop-aging pills the night before the appointment",
+    },
+            {
+              note: "Bicentennial doctor's appointment",
+              date: new Date("2100-01-01"),
+              extra: "Don't take your stop-aging pills the night before the appointment"
+            }
+          ]
+        ];
+        Qunit.test("Correctly deserializes data", (function (qunit) {
+                qunit.expect(valid.length);
+                Curry._2(Prelude.$$Array.forEach, valid, (function (param) {
+                        var data = param[0];
+                        console.log("Running sample", data);
+                        var result = Curry._1(Deserializer.fromJSON, data);
+                        if (result.TAG === /* Ok */0) {
+                          qunit.deepEqual(result._0, param[1], "result == expected");
+                          return ;
+                        }
+                        console.error(result._0);
+                      }));
+              }));
+        var invalid = [[
+            "Missing non-optional field",
+            {"extra": "Bicentennial doctor's appointment", "date": "2100-01-01"}
+          ]];
+        Qunit.test("Correctly catches invalid data", (function (qunit) {
+                qunit.expect(invalid.length);
+                Curry._2(Prelude.$$Array.forEach, invalid, (function (param) {
+                        var data = param[1];
+                        console.log("Running sample", param[0], data);
+                        var result = Curry._1(Deserializer.fromJSON, data);
+                        if (result.TAG === /* Ok */0) {
+                          console.error("Invalid being accepted: ", result._0);
+                          return ;
+                        }
+                        console.log("Correctly detected:", result._0);
+                        qunit.ok(true, true);
+                      }));
+              }));
+      }));
+
+Qunit.module("Recursive deserializer", (function (param) {
+        var fields = {
+          TAG: /* Object */3,
+          _0: [
+            [
+              "data",
+              /* Any */0
+            ],
+            [
+              "children",
+              {
+                TAG: /* Array */1,
+                _0: /* Self */7
+              }
+            ]
+          ]
+        };
+        var DeserializerImpl = $$JSON.MakeDeserializer({
+              fields: fields
+            });
+        var checkFieldsSanity = DeserializerImpl.checkFieldsSanity;
+        var fromJSON = function (data) {
+          return Curry._2(Prelude.Result.map, Curry._1(DeserializerImpl.fromJSON, data), (function (prim) {
+                        return prim;
+                      }));
+        };
+        var valid = [[
+            {"data": "A", "children": [{"data": "A1", "children": []}, {"data": "B", "children": [{"data": "C", "children": []}, {"data": "D", "children": []}]}]},
+            {
+              data: "A",
+              children: [
+                {
+                  data: "A1",
+                  children: []
+                },
+                {
+                  data: "B",
+                  children: [
+                    {
+                      data: "C",
+                      children: []
+                    },
+                    {
+                      data: "D",
+                      children: []
+                    }
+                  ]
+                }
+              ]
+            }
+          ]];
+        Qunit.test("Trivial recursion detection: Ok", (function (qunit) {
+                qunit.expect(1);
+                qunit.deepEqual(Curry._1(checkFieldsSanity, undefined), {
+                      TAG: /* Ok */0,
+                      _0: undefined
+                    }, "Ok");
+              }));
+        Qunit.test("Infinite list", (function (qunit) {
+                var fields = {
+                  TAG: /* Object */3,
+                  _0: [
+                    [
+                      "head",
+                      /* String */1
+                    ],
+                    [
+                      "tail",
+                      /* Self */7
+                    ]
+                  ]
+                };
+                var InfiniteList = $$JSON.MakeDeserializer({
+                      fields: fields
+                    });
+                qunit.expect(1);
+                qunit.deepEqual(Curry._1(Prelude.Result.isError, Curry._1(InfiniteList.checkFieldsSanity, undefined)), true, "Ok");
+              }));
+        Qunit.test("Finite list", (function (qunit) {
+                var fields = {
+                  TAG: /* Object */3,
+                  _0: [
+                    [
+                      "head",
+                      /* String */1
+                    ],
+                    [
+                      "tail",
+                      {
+                        TAG: /* Optional */4,
+                        _0: /* Self */7
+                      }
+                    ]
+                  ]
+                };
+                var List = $$JSON.MakeDeserializer({
+                      fields: fields
+                    });
+                qunit.expect(1);
+                qunit.deepEqual(Curry._1(List.checkFieldsSanity, undefined), {
+                      TAG: /* Ok */0,
+                      _0: undefined
+                    }, "Ok");
+              }));
+        Qunit.test("Correctly deserializes recursive data", (function (qunit) {
+                qunit.expect(valid.length);
+                Curry._2(Prelude.$$Array.forEach, valid, (function (param) {
+                        var data = param[0];
+                        console.log("Running sample", data);
+                        var result = fromJSON(data);
+                        if (result.TAG === /* Ok */0) {
+                          qunit.deepEqual(result._0, param[1], "result == expected");
+                          return ;
+                        }
+                        console.error(result._0);
+                      }));
+              }));
+        Qunit.test("Recursion in sub-deserializer", (function (qunit) {
+                var fields = {
+                  TAG: /* Object */3,
+                  _0: [
+                    [
+                      "head",
+                      /* String */1
+                    ],
+                    [
+                      "tail",
+                      {
+                        TAG: /* Optional */4,
+                        _0: /* Self */7
+                      }
+                    ]
+                  ]
+                };
+                var List = $$JSON.MakeDeserializer({
+                      fields: fields
+                    });
+                var fields$1 = {
+                  TAG: /* Object */3,
+                  _0: [
+                    [
+                      "records",
+                      {
+                        TAG: /* Deserializer */7,
+                        _0: List
+                      }
+                    ],
+                    [
+                      "next",
+                      {
+                        TAG: /* Optional */4,
+                        _0: /* Self */7
+                      }
+                    ]
+                  ]
+                };
+                var Ledger = $$JSON.MakeDeserializer({
+                      fields: fields$1
+                    });
+                var data = {"records": {"head": "A", "tail": {"head": "B"}},
+        "next": {"records": {"head": "A", "tail": {"head": "B"}}}};
+                var expected = {
+                  records: {
+                    head: "A",
+                    tail: {
+                      head: "B",
+                      tail: undefined
+                    }
+                  },
+                  next: {
+                    records: {
+                      head: "A",
+                      tail: {
+                        head: "B",
+                        tail: undefined
+                      }
+                    },
+                    next: undefined
+                  }
+                };
+                qunit.expect(1);
+                qunit.deepEqual(Curry._1(Ledger.fromJSON, data), {
+                      TAG: /* Ok */0,
+                      _0: expected
+                    }, "nice ledger");
+              }));
+      }));
+
+export {
+  Appointment ,
+}
+/* Deserializer Not a pure module */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaiko.io/rescript-deser",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "keywords": [
     "json",
     "deserializer",
@@ -19,7 +19,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@kaiko.io/rescript-prelude": "^6.2.1",
+    "@kaiko.io/rescript-prelude": "^6.2.2",
     "rescript": "^10.1.4"
   },
   "devDependencies": {