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

package/lib/bs/.bsdeps

@@ -1,8 +1,8 @@
-11.0.0-rc.6
+11.0.0-rc.8
 /home/manu/src/kaiko/rescript-deser
 0
-rescript.json	0x1.94b3a6a1d2ba4p+30
+rescript.json	0x1.95f132e38e01fp+30
 tests	0x1.93fb8b23e3f01p+30
-src/	0x1.957e56214e505p+30
+src/	0x1.95f132e38e01fp+30
 ===
-/home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/rescript.exe	0x1.9578a22fcfdf4p+30
+/home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/rescript.exe	0x1.960678820e55cp+30

package/lib/bs/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1700765549343)
-#Done(1700765549343)
+#Start(1702993871083)
+#Done(1702993871083)

package/lib/bs/.ninja_log

@@ -1,27 +1,19 @@
 # ninja log v6
-0	7	1700763106509919117	src/JSON.ast	3df97f11bfe4e9b4
-7	9	1700763106513252576	src/JSON.d	54f2190af6eab30f
-9	26	1700763106529919867	src/JSON.cmj	f5326fd4af8f39e2
-9	26	1700763106529919867	src/JSON.cmi	f5326fd4af8f39e2
-9	26	1700763106529919867	../es6/src/JSON.js	f5326fd4af8f39e2
-0	16	1700763106513252576	src/JSON.cmj	9477bd76994296b7
-0	16	1700763106513252576	src/JSON.cmi	9477bd76994296b7
-0	16	1700763106513252576	../es6/src/JSON.js	9477bd76994296b7
-0	6	1700765531805623915	tests/QUnit.ast	a6a94a20e20f8557
-1	6	1700765531805623915	tests/index.ast	3c91d8240b8bb4b8
-0	8	1700765531808957333	src/JSON.ast	54dacc9e71f78ec4
-6	8	1700765531808957333	tests/QUnit.d	4a2631c992d93ce7
-6	8	1700765531808957333	tests/index.d	5a4db9cdecd186b3
-8	10	1700765531808957333	src/JSON.d	cd2d6773c781340f
-8	15	1700765531815624169	tests/QUnit.cmj	e2ba8efce8af03b9
-8	15	1700765531815624169	tests/QUnit.cmi	e2ba8efce8af03b9
-8	15	1700765531815624169	../es6/tests/QUnit.js	e2ba8efce8af03b9
-8	15	1700765531815624169	../js/tests/QUnit.js	e2ba8efce8af03b9
-10	28	1700765531828957841	src/JSON.cmj	3da9e5f359841f1a
-10	28	1700765531828957841	src/JSON.cmi	3da9e5f359841f1a
-10	28	1700765531828957841	../es6/src/JSON.js	3da9e5f359841f1a
-10	28	1700765531828957841	../js/src/JSON.js	3da9e5f359841f1a
-28	38	1700765531838958094	tests/index.cmj	630554c615a94d8d
-28	38	1700765531838958094	tests/index.cmi	630554c615a94d8d
-28	38	1700765531838958094	../es6/tests/index.js	630554c615a94d8d
-28	38	1700765531838958094	../js/tests/index.js	630554c615a94d8d
+0	6	1702993853375601095	tests/QUnit.ast	2e0ab126f969eb05
+0	7	1702993853375601095	tests/index.ast	71b3927cad444e4e
+0	8	1702993853378934529	src/JSON.ast	9351863d7438f8a8
+6	8	1702993853378934529	tests/QUnit.d	4a2631c992d93ce7
+7	9	1702993853378934529	tests/index.d	5a4db9cdecd186b3
+8	10	1702993853378934529	src/JSON.d	cd2d6773c781340f
+8	15	1702993853385601399	tests/QUnit.cmj	1edb54518110233d
+8	15	1702993853385601399	tests/QUnit.cmi	1edb54518110233d
+8	15	1702993853385601399	../es6/tests/QUnit.js	1edb54518110233d
+8	15	1702993853385601399	../js/tests/QUnit.js	1edb54518110233d
+10	28	1702993853398935137	src/JSON.cmj	8c11ebba20f6863e
+10	28	1702993853398935137	src/JSON.cmi	8c11ebba20f6863e
+10	28	1702993853398935137	../es6/src/JSON.js	8c11ebba20f6863e
+10	28	1702993853398935137	../js/src/JSON.js	8c11ebba20f6863e
+28	38	1702993853408935441	tests/index.cmj	ef71549c32d73e54
+28	38	1702993853408935441	tests/index.cmi	ef71549c32d73e54
+28	38	1702993853408935441	../es6/tests/index.js	ef71549c32d73e54
+28	38	1702993853408935441	../js/tests/index.js	ef71549c32d73e54

package/lib/bs/build.ninja

@@ -1,7 +1,7 @@
 rescript = 1
 g_finger := /home/manu/src/kaiko/rescript-deser/node_modules/@kaiko.io/rescript-prelude/lib/ocaml/install.stamp
 rule astj
-  command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsc.exe  -warn-error +8+11+26+27+33+56 -bs-v 11.0.0-rc.6 -uncurried  -absname -bs-ast -o $out $i
+  command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsc.exe  -warn-error +8+11+26+27+33+56 -bs-v 11.0.0-rc.8 -uncurried  -absname -bs-ast -o $out $i
 o tests/index.ast : astj ../../tests/index.res
 rule deps_dev
   command = /home/manu/src/kaiko/rescript-deser/node_modules/rescript/linux/bsb_helper.exe -g -hash 84aecc33f8594375b23a1a137b057f93 $in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaiko.io/rescript-deser",
-  "version": "4.0.0-rc.4",
+  "version": "4.0.0-rc.6",
   "keywords": [
     "json",
     "deserializer",
@@ -20,11 +20,11 @@
     "README.md"
   ],
   "dependencies": {
-    "@kaiko.io/rescript-prelude": "7.0.0-rc.4"
+    "@kaiko.io/rescript-prelude": "7.0.0-rc.7"
   },
   "devDependencies": {
     "esbuild": "^0.15.7",
     "qunit": "^2.16.0",
-    "rescript": "11.0.0-rc.6"
+    "rescript": "11.0.0-rc.8"
   }
 }

package/lib/ocaml/.compiler.log

@@ -1,2 +0,0 @@
-#Start(1700763494807)
-#Done(1700763494809)

package/lib/ocaml/.ninja_log

@@ -1,7 +0,0 @@
-# ninja log v6
-0	3	1700763106533253326	JSON.cmi	bafb789a597a23fb
-0	3	1700763106533253326	JSON.cmj	e0df0c7e15c09f8e
-0	3	1700763106533253326	JSON.cmt	cb51be205f02087e
-1	3	1700763106533253326	JSON.res	b4c17270ea3dc72d
-3	4	1700763106536586783	install.stamp	cff5a5b4c02d30cf
-0	2	1700763494803628812	JSON.cmt	cb51be205f02087e

package/lib/ocaml/JSON.res

@@ -1,343 +0,0 @@
-@@uncurried
-open Prelude
-
-module FieldValue = {
-  type t
-  external string: string => t = "%identity"
-  external int: int => t = "%identity"
-  external float: float => t = "%identity"
-  external boolean: bool => t = "%identity"
-  external array: array<t> => t = "%identity"
-  external object: Dict.t<t> => t = "%identity"
-  external mapping: Dict.t<t> => t = "%identity"
-  external any: 'a => t = "%identity"
-  @val external null: t = "undefined"
-
-  external asString: t => string = "%identity"
-  external asInt: t => int = "%identity"
-  external asFloat: t => float = "%identity"
-  external asBoolean: t => bool = "%identity"
-  external asArray: t => array<'a> = "%identity"
-  external asObject: t => 'a = "%identity"
-}
-
-exception TypeError(string)
-
-@doc("The module type of a built deserializer which is suitable to add as a subparser.")
-module type Deserializer = {
-  type t
-  let name: string
-  let fromJSON: Js.Json.t => result<t, string>
-  let checkFieldsSanity: unit => result<unit, string>
-}
-
-module Field = {
-  type rec t =
-    | Any
-    | String
-    | Literal(string)
-    | Int
-    | Float
-    | Boolean
-    | Array(t)
-    /// These SHOULD strings in ISO format, but we only validate the string
-    /// can be represented in Js.Date without spewing NaN all over the place;
-    /// Js.Date.fromString("xxx") returns an object that is mostly unusable.
-    ///
-    /// We also allow floats and then use Js.Date.fromFloat.
-    | Date
-    | Datetime // alias of Date
-
-    | Tuple(array<t>)
-    | Object(array<(string, t)>)
-    | Optional(t)
-    | OptionalWithDefault(t, FieldValue.t)
-    /// An arbitrary mapping from names to other arbitrary fields.  The
-    /// difference with Object, is that you don't know the names of the
-    /// expected entries.
-    | Mapping(t)
-
-    | Deserializer(module(Deserializer))
-
-    /// A specialized Array of deserialized items that ignores unparsable
-    /// items and returns the valid collection.  This saves the user from
-    /// writing 'Array(DefaultWhenInvalid(Optional(Deserializer(module(M)))))'
-    /// and then post-process the list of items with 'Array.keepSome'
-    | Collection(module(Deserializer))
-    | DefaultWhenInvalid(t, FieldValue.t)
-
-    // FIXME: this is used to add additional restrictions like variadictInt or
-    // variadicString; but I find it too type-unsafe.  I might consider having
-    // a Constraints for this in the future.
-    | Morphism(t, FieldValue.t => FieldValue.t)
-
-    | Self
-
-  let usingString = (f: string => 'a) => value => value->FieldValue.asString->f->FieldValue.any
-  let usingInt = (f: int => 'a) => value => value->FieldValue.asInt->f->FieldValue.any
-  let usingFloat = (f: float => 'a) => value => value->FieldValue.asFloat->f->FieldValue.any
-  let usingBoolean = (f: bool => 'a) => value => value->FieldValue.asBoolean->f->FieldValue.any
-  let usingArray = (f: array<'a> => 'b) => value => value->FieldValue.asArray->f->FieldValue.any
-  let usingObject = (f: 'a => 'b) => value => value->FieldValue.asObject->f->FieldValue.any
-
-  let variadicInt = (hint: string, fromJs: int => option<'variadicType>) => Morphism(
-    Int,
-    usingInt(i => {
-      switch i->fromJs {
-      | Some(internalValue) => internalValue
-      | None =>
-        raise(TypeError(`This Int(${i->Int.toString}) not a valid value here. Hint: ${hint}`))
-      }
-    }),
-  )
-  let variadicString = (hint: string, fromJs: string => option<'variadicType>) => Morphism(
-    String,
-    usingString(i => {
-      switch i->fromJs {
-      | Some(internalValue) => internalValue
-      | None => raise(TypeError(`This String("${i}") not a valid value here. Hint: ${hint}`))
-      }
-    }),
-  )
-
-  let rec toString = (type_: t) =>
-    switch type_ {
-    | Any => "Any"
-    | String => "String"
-    | Literal(lit) => `Literal: ${lit}`
-    | Int => "Integer"
-    | Float => "Float"
-    | Boolean => "Boolean"
-    | Datetime
-    | Date => "Date"
-    | Self => "Self (recursive)"
-    | Collection(m) => {
-        module M = unpack(m: Deserializer)
-        "Collection of " ++ M.name
-      }
-
-    | Array(t) => "Array of " ++ t->toString
-    | Tuple(bases) => `Tuple of (${bases->Array.map(toString)->Array.join(", ")})`
-    | Object(fields) => {
-        let desc = fields->Array.map(((field, t)) => `${field}: ${t->toString}`)->Array.join(", ")
-        `Object of {${desc}}`
-      }
-
-    | OptionalWithDefault(t, _)
-    | Optional(t) =>
-      "Null of " ++ t->toString
-    | Mapping(t) => `Mapping of ${t->toString}`
-    | Morphism(t, _) => t->toString ++ " to apply a morphism"
-    | Deserializer(m) => {
-        module M = unpack(m: Deserializer)
-        M.name
-      }
-
-    | DefaultWhenInvalid(t, _) => `Protected ${t->toString}`
-    }
-
-  let _taggedToString = (tagged: Js.Json.tagged_t) => {
-    switch tagged {
-    | Js.Json.JSONFalse => "Boolean(false)"
-    | Js.Json.JSONTrue => "Boolean(true)"
-    | Js.Json.JSONNull => "Null"
-    | Js.Json.JSONString(text) => `String("${text}")`
-    | Js.Json.JSONNumber(number) => `Number(${number->Float.toString})`
-    | Js.Json.JSONObject(obj) => `Object(${obj->Js.Json.stringifyAny->default("...")})`
-    | Js.Json.JSONArray(array) => `Array(${array->Js.Json.stringifyAny->default("...")})`
-    }
-  }
-
-  let rec extractValue = (
-    values: Dict.t<Js.Json.t>,
-    field: string,
-    shape: t,
-    self: t,
-  ): FieldValue.t => {
-    switch values->Dict.get(field) {
-    | Some(value) => value->fromUntagged(shape, self)
-    | None =>
-      switch shape {
-      | DefaultWhenInvalid(_, _) => Js.Json.null->fromUntagged(shape, self)
-      | Optional(_) => Js.Json.null->fromUntagged(shape, self)
-      | OptionalWithDefault(_, default) => default
-      | _ => raise(TypeError(`Missing non-optional field '${field}'`))
-      }
-    }
-  }
-  and fromUntagged = (untagged: Js.Json.t, shape: t, self: t): FieldValue.t => {
-    switch (shape, untagged->Js.Json.classify) {
-    | (Any, _) => untagged->FieldValue.any
-    | (Literal(expected), Js.Json.JSONString(text)) =>
-      if text == expected {
-        FieldValue.string(text)
-      } else {
-        raise(TypeError(`Expecting literal ${expected}, got ${text}`))
-      }
-    | (String, Js.Json.JSONString(text)) => FieldValue.string(text)
-    | (Int, Js.Json.JSONNumber(number)) => FieldValue.int(number->Float.toInt)
-    | (Float, Js.Json.JSONNumber(number)) => FieldValue.float(number)
-    | (Boolean, Js.Json.JSONTrue) => FieldValue.boolean(true)
-    | (Boolean, Js.Json.JSONFalse) => FieldValue.boolean(false)
-    | (Tuple(bases), Js.Json.JSONArray(items)) => {
-        let lenbases = bases->Array.length
-        let lenitems = items->Array.length
-        if lenbases == lenitems {
-          let values = Array.zipBy(items, bases, (i, b) => fromUntagged(i, b, self))
-          values->FieldValue.array
-        } else {
-          raise(
-            TypeError(`Expecting ${lenbases->Int.toString} items, got ${lenitems->Int.toString}`),
-          )
-        }
-      }
-
-    | (Datetime, Js.Json.JSONString(s))
-    | (Date, Js.Json.JSONString(s)) => {
-        let r = Js.Date.fromString(s)
-        if r->Js.Date.getDate->Js.Float.isNaN {
-          raise(TypeError(`Invalid date ${s}`))
-        }
-        r->FieldValue.any
-      }
-
-    | (Datetime, Js.Json.JSONNumber(f))
-    | (Date, Js.Json.JSONNumber(f)) => {
-        let r = Js.Date.fromFloat(f)
-        if r->Js.Date.getDate->Js.Float.isNaN {
-          raise(TypeError(`Invalid date ${f->Js.Float.toString}`))
-        }
-        r->FieldValue.any
-      }
-
-    | (Array(shape), Js.Json.JSONArray(items)) =>
-      FieldValue.array(items->Array.map(item => item->fromUntagged(shape, self)))
-    | (Mapping(f), Js.Json.JSONObject(values)) =>
-      values->Dict.mapValues(v => v->fromUntagged(f, self))->FieldValue.mapping
-    | (Object(fields), Js.Json.JSONObject(values)) =>
-      FieldValue.object(
-        fields
-        ->Array.map(((field, shape)) => {
-          let value = switch extractValue(values, field, shape, self) {
-          | value => value
-          | exception TypeError(msg) => raise(TypeError(`Field "${field}": ${msg}`))
-          }
-          (field, value)
-        })
-        ->Dict.fromArray,
-      )
-
-    | (OptionalWithDefault(_, value), Js.Json.JSONNull) => value
-    | (OptionalWithDefault(shape, _), _) => untagged->fromUntagged(shape, self)
-    | (Optional(_), Js.Json.JSONNull) => FieldValue.null
-    | (Optional(shape), _) => untagged->fromUntagged(shape, self)
-    | (Morphism(shape, f), _) => untagged->fromUntagged(shape, self)->f->FieldValue.any
-
-    | (Collection(m), Js.Json.JSONArray(items)) => {
-        module M = unpack(m: Deserializer)
-        items
-        ->Array.map(M.fromJSON)
-        ->Array.map(Result.warn)
-        ->Array.keepSome
-        ->Array.map(FieldValue.any)
-        ->FieldValue.array
-      }
-
-    | (Deserializer(m), _) => {
-        module M = unpack(m: Deserializer)
-        switch untagged->M.fromJSON {
-        | Ok(res) => res->FieldValue.any
-        | Error(msg) => raise(TypeError(msg))
-        }
-      }
-
-    | (DefaultWhenInvalid(t, default), _) =>
-      switch untagged->fromUntagged(t, self) {
-      | res => res
-      | exception TypeError(msg) => {
-          Js.Console.warn2("Detected and ignore (with default): ", msg)
-          default
-        }
-      }
-    | (Self, _) => untagged->fromUntagged(self, self)
-    | (expected, actual) =>
-      raise(TypeError(`Expected ${expected->toString}, but got ${actual->_taggedToString} instead`))
-    }
-  }
-
-  let rec checkFieldsSanity = (name: string, fields: t, optional: bool): result<unit, string> =>
-    switch (fields, optional) {
-    | (Self, false) => Error(`${name}: Trivial infinite recursion 'let fields = Self'`)
-    | (Self, true) => Ok()
-
-    | (Any, _) => Ok()
-    | (String, _) | (Float, _) | (Int, _) | (Literal(_), _) => Ok()
-    | (Boolean, _) | (Date, _) | (Datetime, _) => Ok()
-    | (Morphism(_, _), _) => Ok()
-
-    | (Collection(mod), _)
-    | (Deserializer(mod), _) => {
-        module M = unpack(mod: Deserializer)
-        switch M.checkFieldsSanity() {
-        | Ok() => Ok()
-        | Error(msg) => Error(`${name}/ ${msg}`)
-        }
-      }
-
-    | (DefaultWhenInvalid(fields, _), _)
-    | (OptionalWithDefault(fields, _), _)
-    | (Optional(fields), _) =>
-      checkFieldsSanity(name, fields, true)
-
-    | (Object(fields), optional) =>
-      fields
-      ->Array.map(((fieldName, field)) => () =>
-        checkFieldsSanity(`${name}::${fieldName}`, field, optional))
-      ->ManyResults.bailU
-      ->ManyResults.map(_ => ())
-
-    /// Mappings and arrays can be empty, so their payloads are
-    /// automatically optional.
-    | (Mapping(field), _) | (Array(field), _) => checkFieldsSanity(name, field, true)
-
-    | (Tuple(fields), optional) =>
-      fields
-      ->Array.mapWithIndex((field, index) => () =>
-        checkFieldsSanity(`${name}[${index->Int.toString}]`, field, optional))
-      ->ManyResults.bailU
-      ->ManyResults.map(_ => ())
-    }
-}
-
-module type Serializable = {
-  type t
-  let fields: Field.t
-}
-
-module MakeDeserializer = (S: Serializable): (Deserializer with type t = S.t) => {
-  type t = S.t
-  let fields = S.fields
-  %%private(let (loc, _f) = __LOC_OF__(module(S: Serializable)))
-  let name = `Deserializer ${__MODULE__}, ${loc}`
-
-  %%private(external _toNativeType: FieldValue.t => t = "%identity")
-
-  @doc("Checks for trivial infinite-recursion in the fields of the module.
-
-  Notice this algorithm is just an heuristic, and it might happen that are
-  cases of infinite-recursion not detected and cases where detection is a
-  false positive.
-
-  You should use this only while debugging/developing to verify your data.
-
-  ")
-  let checkFieldsSanity = () => Field.checkFieldsSanity(name, fields, false)
-
-  @doc("Parse a `Js.Json.t` into `result<t, string>`")
-  let fromJSON = (json: Js.Json.t): result<t, _> => {
-    switch json->Field.fromUntagged(fields, fields) {
-    | res => Ok(res->_toNativeType)
-    | exception TypeError(e) => Error(e)
-    }
-  }
-}