@colisweb/rescript-toolkit 2.15.0 → 2.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colisweb/rescript-toolkit",
-  "version": "2.15.0",
+  "version": "2.16.0",
   "scripts": {
     "clean": "rescript clean",
     "build": "rescript build",

package/src/decoders/Toolkit__Decoders.res

@@ -121,27 +121,27 @@ module type EnumConfig = {
 }
 
 module Enum = (Config: EnumConfig) => {
-  type enum = Config.enum
+  %%private(
+    let encoder = value => value->Config.enumToJs->Decco.stringToJson
 
-  let encoder = value => value->Config.enumToJs->Decco.stringToJson
-
-  let decoder = json =>
-    switch Decco.stringFromJson(json) {
-    | Ok(value) =>
-      switch Config.enumFromJs(value) {
-      | None => Decco.error(~path="", "Invalid enum " ++ value, json)
-      | Some(value) => Ok(value)
+    let decoder = json =>
+      switch Decco.stringFromJson(json) {
+      | Ok(value) =>
+        switch Config.enumFromJs(value) {
+        | None => Decco.error(~path="", "Invalid enum " ++ value, json)
+        | Some(value) => Ok(value)
+        }
+      | Error(_) as error => error
       }
-    | Error(_) as error => error
-    }
 
-  let codec = (encoder, decoder)
+    let codec = (encoder, decoder)
+  )
 
   let toString = v => v->Config.enumToJs
   let fromString = v => v->Config.enumFromJs
 
   @decco
-  type t = @decco.codec(codec) enum
+  type t = @decco.codec(codec) Config.enum
 }
 
 module Option = {
@@ -161,337 +161,219 @@ module Option = {
 }
 
 module UnitMeasure = {
-  module Dimension = {
-    module WithUnit = {
-      let encoder: Decco.encoder<Toolkit__Utils_UnitMeasure.Dimension.t> = value =>
-        value->Toolkit__Utils_UnitMeasure.Dimension.toString()->Decco.stringToJson
+  module type MakeConfig = {
+    type t
+    let toString: t => string
+    let toValue: t => float
+    let display: (t, ~digits: int=?, unit) => string
 
-      let decoder: Decco.decoder<Toolkit__Utils_UnitMeasure.Dimension.t> = json =>
-        switch Decco.stringFromJson(json) {
-        | Belt.Result.Ok(v) =>
-          let valueUnitArray = v->Js.String2.split(" ")
-          switch (
-            valueUnitArray[0]->Belt.Option.flatMap(Belt.Float.fromString),
-            valueUnitArray[1],
-          ) {
-          | (Some(v), Some("mm")) => #mm(v)->Ok
-          | (Some(v), Some("cm")) => #cm(v)->Ok
-          | (Some(v), Some("dm")) => #dm(v)->Ok
-          | (Some(v), Some("km")) => #km(v)->Ok
-          | (None, _) => Decco.error("unhandled no value", json)
-          | (_, None) => Decco.error("unhandled no unit", json)
-          | (_, Some(_)) => Decco.error("unhandled dimension unit", json)
-          }
-        | Belt.Result.Error(_) as err => err
-        }
+    let wrapValue: float => t
+  }
 
-      let codec: Decco.codec<Toolkit__Utils_UnitMeasure.Dimension.t> = (encoder, decoder)
-      let toValue = Toolkit__Utils_UnitMeasure.Dimension.toValue
-      let toString = Toolkit__Utils_UnitMeasure.Dimension.toString
+  module Make = (C: MakeConfig) => {
+    type dimension = C.t
 
-      @decco
-      type t = @decco.codec(codec) Toolkit__Utils_UnitMeasure.Dimension.t
-    }
+    let encoder: Decco.encoder<C.t> = value => value->C.toString->Decco.stringToJson
 
-    module type DimensionConfig = {
-      let convert: float => Toolkit__Utils_UnitMeasure.Dimension.t
-    }
-    module Make = (C: DimensionConfig) => {
-      type dimension = Toolkit__Utils_UnitMeasure.Dimension.t
+    let decoder: Decco.decoder<C.t> = json =>
+      switch Decco.floatFromJson(json) {
+      | Ok(v) => v->C.wrapValue->Ok
+      | Error(_) as err => err
+      }
 
-      let encoder: Decco.encoder<Toolkit__Utils_UnitMeasure.Dimension.t> = value =>
-        value->Toolkit__Utils_UnitMeasure.Dimension.toString()->Decco.stringToJson
+    let codec: Decco.codec<dimension> = (encoder, decoder)
 
-      let decoder: Decco.decoder<Toolkit__Utils_UnitMeasure.Dimension.t> = json =>
-        switch Decco.floatFromJson(json) {
-        | Ok(v) => v->C.convert->Ok
+    let toValue = C.toValue
+    let display = C.display
+    let toString = C.toString
 
-        | Error(_) as err => err
-        }
+    @decco
+    type t = @decco.codec(codec) C.t
+  }
 
-      let codec: Decco.codec<dimension> = (encoder, decoder)
+  module type MakeWithUnitConfig = {
+    type t
+    let toString: t => string
+    let toValue: t => float
+    let display: (t, ~digits: int=?, unit) => string
 
-      @decco
-      type t = @decco.codec(codec) Toolkit__Utils_UnitMeasure.Dimension.t
-    }
+    type unitEnum
+    let unitEnum_decode: Js.Json.t => result<unitEnum, Decco.decodeError>
+    let unitEnum_encode: unitEnum => Js.Json.t
 
-    module Mm = Make({
-      let convert = Toolkit__Utils_UnitMeasure.Dimension.makeMm
-    })
-    module Cm = Make({
-      let convert = Toolkit__Utils_UnitMeasure.Dimension.makeCm
-    })
-    module Dm = Make({
-      let convert = Toolkit__Utils_UnitMeasure.Dimension.makeDm
-    })
-    module Km = Make({
-      let convert = Toolkit__Utils_UnitMeasure.Dimension.makeKm
-    })
-  }
+    let wrapValue: (unitEnum, float) => t
 
-  module Weight = {
-    module WithUnit = {
-      let encoder: Decco.encoder<Toolkit__Utils_UnitMeasure.Weight.t> = value =>
-        value->Toolkit__Utils_UnitMeasure.Weight.display()->Decco.stringToJson
+    let errorPrefix: string
+  }
 
-      let decoder: Decco.decoder<Toolkit__Utils_UnitMeasure.Weight.t> = json =>
-        switch Decco.stringFromJson(json) {
-        | Ok(v) =>
-          let valueUnitArray = v->Js.String2.split(" ")
-          switch (
-            valueUnitArray[0]->Belt.Option.flatMap(Belt.Float.fromString),
-            valueUnitArray[1],
-          ) {
-          | (Some(v), Some("g")) => #g(v)->Ok
-          | (Some(v), Some("kg")) => #kg(v)->Ok
-          | (None, _) => Decco.error("unhandled no value", json)
-          | (_, None) => Decco.error("unhandled no unit", json)
-          | (_, Some(_)) => Decco.error("unhandled weight unit", json)
-          }
+  module MakeWithUnit = (Config: MakeWithUnitConfig) => {
+    let decodeFromString = (string: string) => {
+      // match a positive int or float followed by it's unit (capturing int/float in group1 and unit in group2)
+      let regexp = %re("/^(\d+(?:\.\d*)?)\s*(\D*)$/")
 
-        | Error(_) as err => err
-        }
+      // regexpCaptures: [match , captureGroup1, captureGroup2]
+      let regexpCaptures =
+        Js.Re.exec_(regexp, string)->Belt.Option.map(r =>
+          r->Js.Re.captures->Array.map(Js.Nullable.toOption)
+        )
 
-      let codec: Decco.codec<Toolkit__Utils_UnitMeasure.Weight.t> = (encoder, decoder)
+      let jsonString = string->Js.Json.string
 
-      @decco
-      type t = @decco.codec(codec) Toolkit__Utils_UnitMeasure.Weight.t
-    }
+      let errorPrefix = Config.errorPrefix
 
-    module type WeightConfig = {
-      let convert: float => Toolkit__Utils_UnitMeasure.Weight.t
+      switch regexpCaptures {
+      | None => Decco.error(`${errorPrefix} unhandled format`, jsonString)
+      | Some([None, _value, _unit]) => Decco.error(`${errorPrefix} unhandled format`, jsonString)
+      | Some([_match, _value, None]) => Decco.error(`${errorPrefix} unhandled no unit`, jsonString)
+      | Some([_match, None, _unit]) => Decco.error(`${errorPrefix} unhandled no value`, jsonString)
+      | Some([Some(_match), Some(value), Some(unit)]) => {
+          let value = value->Js.Float.fromString
+          switch unit->Js.Json.string->Config.unitEnum_decode {
+          | Ok(unit) => Config.wrapValue(unit, value)->Ok
+          | Error(_) => Decco.error(`${errorPrefix} unhandled unit '${unit}'`, jsonString)
+          }
+        }
+      | Some(_) => Decco.error(`${errorPrefix} regex capture group error`, jsonString)
+      }
     }
 
-    module Make = (C: WeightConfig) => {
-      type weight = Toolkit__Utils_UnitMeasure.Weight.t
-
-      let encoder: Decco.encoder<Toolkit__Utils_UnitMeasure.Weight.t> = value =>
-        value->Toolkit__Utils_UnitMeasure.Weight.display()->Decco.stringToJson
-
-      let decoder: Decco.decoder<Toolkit__Utils_UnitMeasure.Weight.t> = json =>
-        switch Decco.floatFromJson(json) {
-        | Ok(v) => v->C.convert->Ok
+    %%private(
+      let encoder: Decco.encoder<Config.t> = value => value->Config.toString->Decco.stringToJson
+      let decoder: Decco.decoder<Config.t> = json =>
+        switch Decco.stringFromJson(json) {
+        | Ok(v) => v->decodeFromString
         | Error(_) as err => err
         }
+      let codec: Decco.codec<Config.t> = (encoder, decoder)
+    )
 
-      let codec: Decco.codec<weight> = (encoder, decoder)
+    let toValue = Config.toValue
+    let toString = Config.toString
+    let display = Config.display
 
-      let toValue = Toolkit__Utils_UnitMeasure.Weight.toValue
-      let display = Toolkit__Utils_UnitMeasure.Weight.display
+    @decco
+    type t = @decco.codec(codec) Config.t
+  }
 
-      @decco
-      type t = @decco.codec(codec) Toolkit__Utils_UnitMeasure.Weight.t
-    }
+  module Dimension = {
+    module Config = Toolkit__Utils_UnitMeasure.Dimension
 
-    module G = Make({
-      let convert = Toolkit__Utils_UnitMeasure.Weight.makeG
+    module WithUnit = MakeWithUnit({
+      include Config
+      let errorPrefix = "Dimension with unit"
     })
-    module Kg = Make({
-      let convert = Toolkit__Utils_UnitMeasure.Weight.makeKg
+
+    module Mm = Make({
+      include Config
+      let wrapValue = Config.wrapValue(#mm)
+    })
+    module Cm = Make({
+      include Config
+      let wrapValue = Config.wrapValue(#cm)
+    })
+    module Dm = Make({
+      include Config
+      let wrapValue = Config.wrapValue(#dm)
+    })
+    module M = Make({
+      include Config
+      let wrapValue = Config.wrapValue(#m)
+    })
+    module Km = Make({
+      include Config
+      let wrapValue = Config.wrapValue(#km)
     })
   }
 
-  module Time = {
-    module WithUnit = {
-      let encoder: Decco.encoder<Toolkit__Utils_UnitMeasure.Time.t> = value =>
-        switch value {
-        | #min(v) => Js.Json.string(v->Js.Float.toString ++ " min")
-        | #h(v) => Js.Json.string(v->Js.Float.toString ++ " h")
-        }
-
-      let decoder: Decco.decoder<Toolkit__Utils_UnitMeasure.Time.t> = json =>
-        switch Decco.stringFromJson(json) {
-        | Ok(v) =>
-          let valueUnitArray = v->Js.String2.split(" ")
-          switch (
-            valueUnitArray[0]->Belt.Option.flatMap(Belt.Float.fromString),
-            valueUnitArray[1],
-          ) {
-          | (Some(v), Some("min")) => #min(v)->Ok
-          | (Some(v), Some("h")) => #h(v)->Ok
-          | (None, _) => Decco.error("unhandled no value", json)
-          | (_, None) => Decco.error("unhandled no unit", json)
-          | (_, Some(_)) => Decco.error("unhandled time unit", json)
-          }
+  module Volume = {
+    module Config = Toolkit__Utils_UnitMeasure.Volume
 
-        | Error(_) as err => err
-        }
-
-      let codec: Decco.codec<Toolkit__Utils_UnitMeasure.Time.t> = (encoder, decoder)
-
-      @decco
-      type t = @decco.codec(codec) Toolkit__Utils_UnitMeasure.Time.t
-    }
-
-    module type TimeConfig = {
-      let convert: float => Toolkit__Utils_UnitMeasure.Time.t
-    }
+    module WithUnit = MakeWithUnit({
+      include Config
+      let errorPrefix = "Volume with unit"
+    })
 
-    module Make = (C: TimeConfig) => {
-      type time = Toolkit__Utils_UnitMeasure.Time.t
+    module M3 = Make({
+      include Config
+      let wrapValue = Config.wrapValue(#m3)
+    })
+  }
 
-      let encoder: Decco.encoder<Toolkit__Utils_UnitMeasure.Time.t> = value =>
-        switch value {
-        | #min(v) => Js.Json.string(v->Js.Float.toString ++ " min")
-        | #h(v) => Js.Json.string(v->Js.Float.toString ++ " h")
-        }
+  module Weight = {
+    module Config = Toolkit__Utils_UnitMeasure.Weight
 
-      let decoder: Decco.decoder<Toolkit__Utils_UnitMeasure.Time.t> = json =>
-        switch Decco.floatFromJson(json) {
-        | Ok(v) => v->C.convert->Ok
-        | Error(_) as err => err
-        }
+    module WithUnit = MakeWithUnit({
+      include Config
+      let errorPrefix = "Weight with unit"
+    })
 
-      let codec: Decco.codec<time> = (encoder, decoder)
+    module G = Make({
+      include Config
+      let wrapValue = Config.wrapValue(#g)
+    })
+    module Kg = Make({
+      include Config
+      let wrapValue = Config.wrapValue(#kg)
+    })
+  }
 
-      let toValue = Toolkit__Utils_UnitMeasure.Time.toValue
-      let display = Toolkit__Utils_UnitMeasure.Time.display
+  module Time = {
+    module Config = Toolkit__Utils_UnitMeasure.Time
 
-      @decco
-      type t = @decco.codec(codec) Toolkit__Utils_UnitMeasure.Time.t
-    }
+    module WithUnit = MakeWithUnit({
+      include Config
+      let errorPrefix = "Time with unit"
+    })
 
     module Min = Make({
-      let convert = Toolkit__Utils_UnitMeasure.Time.makeMin
+      include Config
+      let wrapValue = Config.wrapValue(#min)
     })
     module H = Make({
-      let convert = Toolkit__Utils_UnitMeasure.Time.makeH
+      include Config
+      let wrapValue = Config.wrapValue(#h)
     })
   }
 
   module Currency = {
-    module WithUnit = {
-      let encoder: Decco.encoder<Toolkit__Utils_UnitMeasure.Currency.t> = value =>
-        switch value {
-        | #EUR(v) => Js.Json.string(v->Js.Float.toString ++ " EUR")
-        }
-
-      let decoder: Decco.decoder<Toolkit__Utils_UnitMeasure.Currency.t> = json =>
-        switch Decco.stringFromJson(json) {
-        | Ok(v) =>
-          let valueUnitArray = v->Js.String2.split(" ")
-          switch (
-            valueUnitArray[0]->Belt.Option.flatMap(Belt.Float.fromString),
-            valueUnitArray[1],
-          ) {
-          | (Some(v), Some("EUR")) => #EUR(v)->Ok
-          | (None, _) => Decco.error("unhandled no value", json)
-          | (_, None) => Decco.error("unhandled no unit", json)
-          | (_, Some(_)) => Decco.error("unhandled currency unit", json)
-          }
-
-        | Error(_) as err => err
-        }
+    module Config = Toolkit__Utils_UnitMeasure.Currency
 
-      let codec: Decco.codec<Toolkit__Utils_UnitMeasure.Currency.t> = (encoder, decoder)
-
-      @decco
-      type t = @decco.codec(codec) Toolkit__Utils_UnitMeasure.Currency.t
-    }
-
-    module type CurrencyConfig = {
-      let convert: float => Toolkit__Utils_UnitMeasure.Currency.t
-    }
-
-    module Make = (C: CurrencyConfig) => {
-      type currency = Toolkit__Utils_UnitMeasure.Currency.t
-
-      let encoder: Decco.encoder<Toolkit__Utils_UnitMeasure.Currency.t> = value =>
-        switch value {
-        | #EUR(v) => Js.Json.string(v->Js.Float.toString ++ " EUR")
-        }
-
-      let decoder: Decco.decoder<Toolkit__Utils_UnitMeasure.Currency.t> = json =>
-        switch Decco.floatFromJson(json) {
-        | Ok(v) => v->C.convert->Ok
-        | Error(_) as err => err
-        }
-
-      let codec: Decco.codec<currency> = (encoder, decoder)
-
-      let toValue = Toolkit__Utils_UnitMeasure.Currency.toValue
-      let display = Toolkit__Utils_UnitMeasure.Currency.toString
-
-      @decco
-      type t = @decco.codec(codec) Toolkit__Utils_UnitMeasure.Currency.t
-    }
+    module WithUnit = MakeWithUnit({
+      include Config
+      let errorPrefix = "Curency with unit"
+    })
 
     module EUR = Make({
-      let convert = Toolkit__Utils_UnitMeasure.Currency.makeEUR
+      include Config
+      let wrapValue = Config.wrapValue(#EUR)
     })
   }
 
   module CompositeUnits = {
     module CurrencyPerDistance = {
-      module WithUnit = {
-        let encoder: Decco.encoder<
-          Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerDistance.t,
-        > = value =>
-          switch value {
-          | #EUR_km(v) => Js.Json.string(v->Js.Float.toString ++ " EUR/km")
-          }
-
-        let decoder: Decco.decoder<
-          Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerDistance.t,
-        > = json =>
-          switch Decco.stringFromJson(json) {
-          | Ok(v) =>
-            let valueUnitArray = v->Js.String2.split(" ")
-            switch (
-              valueUnitArray[0]->Belt.Option.flatMap(Belt.Float.fromString),
-              valueUnitArray[1],
-            ) {
-            | (Some(v), Some("EUR/km")) => #EUR_km(v)->Ok
-            | (None, _) => Decco.error("unhandled no value", json)
-            | (_, None) => Decco.error("unhandled no unit", json)
-            | (_, Some(_)) => Decco.error("unhandled currencyPerDistance unit", json)
-            }
-
-          | Error(_) as err => err
-          }
-
-        let codec: Decco.codec<Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerDistance.t> = (
-          encoder,
-          decoder,
-        )
+      module Config = Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerDistance
 
-        @decco
-        type t = @decco.codec(codec) Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerDistance.t
-      }
-
-      module type CurrencyPerDistanceConfig = {
-        let convert: float => Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerDistance.t
-      }
-
-      module Make = (C: CurrencyPerDistanceConfig) => {
-        type currencyPerDistance = Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerDistance.t
-
-        let encoder: Decco.encoder<
-          Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerDistance.t,
-        > = value =>
-          switch value {
-          | #EUR_km(v) => Js.Json.string(v->Js.Float.toString ++ " EUR/km")
-          }
-
-        let decoder: Decco.decoder<
-          Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerDistance.t,
-        > = json =>
-          switch Decco.floatFromJson(json) {
-          | Ok(v) => v->C.convert->Ok
-          | Error(_) as err => err
-          }
-
-        let codec: Decco.codec<currencyPerDistance> = (encoder, decoder)
+      module WithUnit = MakeWithUnit({
+        include Config
+        let errorPrefix = "Curency per distance with unit"
+      })
 
-        let toValue = Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerDistance.toValue
-        let display = Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerDistance.toString
+      module EUR_km = Make({
+        include Config
+        let wrapValue = Config.wrapValue(#EUR_km)
+      })
+    }
+    module CurrencyPerTime = {
+      module Config = Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerTime
 
-        @decco
-        type t = @decco.codec(codec) Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerDistance.t
-      }
+      module WithUnit = MakeWithUnit({
+        include Config
+        let errorPrefix = "Curency per time with unit"
+      })
 
-      module EUR_km = Make({
-        let convert = Toolkit__Utils_UnitMeasure.CompositeUnits.CurrencyPerDistance.makeEUR_km
+      module EUR_h = Make({
+        include Config
+        let wrapValue = Config.wrapValue(#EUR_h)
       })
     }
   }

package/src/utils/Toolkit__Utils.res

@@ -1 +1,2 @@
 module UnitMeasure = Toolkit__Utils_UnitMeasure
+module Regex = Toolkit__Utils_Regex

package/src/utils/Toolkit__Utils_Regex.res

@@ -0,0 +1,7 @@
+let positiveIntRegex = %re("/^[0-9]+$/")
+let positiveIntOrFloatRegex = %re("/^[0-9]+(?:\.?[0-9]+)?$/")
+
+module Test = {
+  let isPositiveInt = Js.Re.test_(positiveIntRegex, _)
+  let isPositiveIntOrFloat = Js.Re.test_(positiveIntOrFloatRegex, _)
+}

package/src/utils/Toolkit__Utils_UnitMeasure.res

@@ -1,6 +1,49 @@
+module type UnitConfig = {
+  type unitEnum
+  let unitEnumToJs: unitEnum => string
+  let unitEnumFromJs: string => option<unitEnum>
+}
+
+module Unit = (Config: UnitConfig) => {
+  %%private(
+    let encoder = value => value->Config.unitEnumToJs->Decco.stringToJson
+
+    let decoder = json =>
+      switch Decco.stringFromJson(json) {
+      | Ok(value) =>
+        switch Config.unitEnumFromJs(value) {
+        | None => Decco.error(~path="", "Invalid unitEnum " ++ value, json)
+        | Some(value) => Ok(value)
+        }
+      | Error(_) as error => error
+      }
+
+    let codec = (encoder, decoder)
+  )
+
+  @decco
+  type unitEnum = @decco.codec(codec) Config.unitEnum
+
+  let unitEnumToString = v => v->Config.unitEnumToJs
+  let unitEnumFromString = v => v->Config.unitEnumFromJs
+}
+
 module Weight = {
+  include Unit({
+    @deriving(jsConverter)
+    type unitEnum = [#g | #kg]
+  })
+
+  @decco
   type t = [#g(float) | #kg(float)]
 
+  let wrapValue = (unit, value) => {
+    switch unit {
+    | #g => #g(value)
+    | #kg => #kg(value)
+    }
+  }
+
   let toValue = value =>
     switch value {
     | #g(v)
@@ -12,23 +55,40 @@ module Weight = {
     | #g(v) => v->Js.Float.toFixedWithPrecision(~digits) ++ " g"
     | #kg(v) => v->Js.Float.toFixedWithPrecision(~digits) ++ " kg"
     }
+  let toString = value =>
+    switch value {
+    | #g(v) => v->Float.toString ++ " g"
+    | #kg(v) => v->Float.toString ++ " kg"
+    }
 
   let makeG = (value: float) => #g(value)
   let makeKg = (value: float) => #kg(value)
 }
 
 module Time = {
+  include Unit({
+    @deriving(jsConverter)
+    type unitEnum = [#min | #h]
+  })
+
   type t = [#min(float) | #h(float)]
 
+  let wrapValue = (unit, value) => {
+    switch unit {
+    | #min => #min(value)
+    | #h => #h(value)
+    }
+  }
+
   let toValue = value =>
     switch value {
     | #min(v)
     | #h(v) => v
     }
 
-  type separator = [#units | #colon]
-  let display = (value, ~separator=#units, ()) => {
+  let display = (value, ~digits as _=2, ()) => {
     let _initialDate = Js.Date.make()
+
     let duration = switch value {
     | #min(v) =>
       BsDateFns.intervalToDuration(
@@ -43,32 +103,35 @@ module Time = {
       )
     }
 
-    let mainSeparator = {
-      switch separator {
-      | #units => " h "
-      | #colon => ":"
-      }
-    }
-    let secondarySeparator = {
-      switch separator {
-      | #units => " min"
-      | #colon => ""
-      }
-    }
-
     switch (duration.hours, duration.minutes) {
-    | (Some(h), Some(min)) =>
-      `${h->Int.toString}${mainSeparator}${min->Int.toString}${secondarySeparator}`
+    | (Some(h), Some(min)) if min->Int.toString->String.length === 1 =>
+      `${h->Int.toString} : 0${min->Int.toString}`
+    | (Some(h), Some(min)) => `${h->Int.toString} : ${min->Int.toString}`
     | (Some(h), _) => `${h->Int.toString} h`
     | (_, Some(min)) => `${min->Int.toString} min`
     | _ => ""
     }
   }
-  let makeMin = (value: float) => #min(value)
-  let makeH = (value: float) => #h(value)
+
+  let toString = value =>
+    switch value {
+    | #min(v) => v->Float.toString ++ " min"
+    | #h(v) => v->Float.toString ++ " h"
+    }
 }
 
 module Dimension = {
+  include Unit({
+    @deriving(jsConverter)
+    type unitEnum = [
+      | #mm
+      | #cm
+      | #dm
+      | #m
+      | #km
+    ]
+  })
+
   type t = [
     | #mm(float)
     | #cm(float)
@@ -77,6 +140,15 @@ module Dimension = {
     | #km(float)
   ]
 
+  let wrapValue = (unit: unitEnum, value: float): t =>
+    switch unit {
+    | #mm => #mm(value)
+    | #cm => #cm(value)
+    | #dm => #dm(value)
+    | #m => #m(value)
+    | #km => #km(value)
+    }
+
   let toValue = value =>
     switch value {
     | #mm(v)
@@ -86,7 +158,7 @@ module Dimension = {
     | #km(v) => v
     }
 
-  let toString = (value, ~digits=2, ()) => {
+  let display = (value, ~digits=2, ()) => {
     open Js.Float
     switch value {
     | #mm(v) => v->toFixedWithPrecision(~digits) ++ " mm"
@@ -97,18 +169,70 @@ module Dimension = {
     }
   }
 
-  let makeMm = (value: float) => #mm(value)
-  let makeCm = (value: float) => #cm(value)
-  let makeDm = (value: float) => #dm(value)
-  let makeM = (value: float) => #m(value)
-  let makeKm = (value: float) => #km(value)
+  let toString = value => {
+    switch value {
+    | #mm(v) => v->Float.toString ++ " mm"
+    | #cm(v) => v->Float.toString ++ " cm"
+    | #dm(v) => v->Float.toString ++ " dm"
+    | #m(v) => v->Float.toString ++ " m"
+    | #km(v) => v->Float.toString ++ " km"
+    }
+  }
+}
+
+module Volume = {
+  include Unit({
+    @deriving(jsConverter)
+    type unitEnum = [
+      | @as(`m³`) #m3
+    ]
+  })
+
+  type t = [
+    | #m3(float)
+  ]
+
+  let wrapValue = (unit: unitEnum, value: float): t =>
+    switch unit {
+    | #m3 => #m3(value)
+    }
+
+  let toValue = value =>
+    switch value {
+    | #m3(value) => value
+    }
+
+  let display = (value, ~digits=2, ()) => {
+    open Js.Float
+    switch value {
+    | #m3(v) => v->toFixedWithPrecision(~digits) ++ ` m³`
+    }
+  }
+
+  let toString = value => {
+    switch value {
+    | #m3(v) => v->Float.toString ++ ` m³`
+    }
+  }
 }
 
 module Currency = {
+  include Unit({
+    @deriving(jsConverter)
+    type unitEnum = [
+      | #EUR
+    ]
+  })
+
   type t = [
     | #EUR(float)
   ]
 
+  let wrapValue = (unit: unitEnum, value: float): t =>
+    switch unit {
+    | #EUR => #EUR(value)
+    }
+
   let toValue = value =>
     switch value {
     | #EUR(v) => v
@@ -120,15 +244,31 @@ module Currency = {
     }
   }
 
-  let makeEUR = (value: float) => #EUR(value)
+  let display = (value, ~digits=2, ()) => {
+    switch value {
+    | #EUR(v) => v->Js.Float.toFixedWithPrecision(~digits) ++ " EUR"
+    }
+  }
 }
 
 module CompositeUnits = {
   module CurrencyPerDistance = {
+    include Unit({
+      @deriving(jsConverter)
+      type unitEnum = [
+        | @as("EUR/km") #EUR_km
+      ]
+    })
+
     type t = [
       | #EUR_km(float)
     ]
 
+    let wrapValue = (unit: unitEnum, value: float): t =>
+      switch unit {
+      | #EUR_km => #EUR_km(value)
+      }
+
     let toValue = value =>
       switch value {
       | #EUR_km(v) => v
@@ -140,6 +280,45 @@ module CompositeUnits = {
       }
     }
 
-    let makeEUR_km = (value: float) => #EUR_km(value)
+    let display = (value, ~digits=2, ()) => {
+      switch value {
+      | #EUR_km(v) => v->Js.Float.toFixedWithPrecision(~digits) ++ " EUR/km"
+      }
+    }
+  }
+
+  module CurrencyPerTime = {
+    include Unit({
+      @deriving(jsConverter)
+      type unitEnum = [
+        | @as("EUR/h") #EUR_h
+      ]
+    })
+
+    type t = [
+      | #EUR_h(float)
+    ]
+
+    let wrapValue = (unit: unitEnum, value: float): t =>
+      switch unit {
+      | #EUR_h => #EUR_h(value)
+      }
+
+    let toValue = value =>
+      switch value {
+      | #EUR_h(v) => v
+      }
+
+    let toString = value => {
+      switch value {
+      | #EUR_h(v) => v->Float.toString ++ " EUR/h"
+      }
+    }
+
+    let display = (value, ~digits=2, ()) => {
+      switch value {
+      | #EUR_h(v) => v->Js.Float.toFixedWithPrecision(~digits) ++ " EUR/h"
+      }
+    }
   }
 }

package/src/vendors/BsDateFns.res

@@ -130,6 +130,8 @@ external getWeekNumber: (Js.Date.t, startOfWeekOptions) => int = "getWeek"
 
 @module("date-fns")
 external getDay: Js.Date.t => int = "getDay"
+@module("date-fns")
+external getHours: Js.Date.t => int = "getHours"
 
 @module("date-fns")
 external parse: string => Js.Date.t = "parse"
@@ -146,3 +148,18 @@ external nextFriday: Js.Date.t => Js.Date.t = "nextFriday"
 external nextSaturday: Js.Date.t => Js.Date.t = "nextSaturday"
 @module("date-fns")
 external nextSunday: Js.Date.t => Js.Date.t = "nextSunday"
+
+@module("date-fns")
+external isMonday: Js.Date.t => bool = "isMonday"
+@module("date-fns")
+external isTuesday: Js.Date.t => bool = "isTuesday"
+@module("date-fns")
+external isWednesday: Js.Date.t => bool = "isWednesday"
+@module("date-fns")
+external isThursday: Js.Date.t => bool = "isThursday"
+@module("date-fns")
+external isFriday: Js.Date.t => bool = "isFriday"
+@module("date-fns")
+external isSaturday: Js.Date.t => bool = "isSaturday"
+@module("date-fns")
+external isSunday: Js.Date.t => bool = "isSunday"

package/src/vendors/ReactBigCalendar.res

@@ -2,7 +2,7 @@ type event<'a> = {
   title: string,
   start: Js.Date.t,
   end: Js.Date.t,
-  resource: Js.t<'a>,
+  resource: 'a,
 }
 
 type view = [
@@ -14,7 +14,7 @@ type view = [
 ]
 
 type eventProp<'a> = {
-  resource: Js.t<'a>,
+  resource: 'a,
   start: Js.Date.t,
   end: Js.Date.t,
   isSelected: bool,
@@ -30,6 +30,11 @@ external makeEventClassStyle: (
   unit,
 ) => eventClassStyle = ""
 
+type timeSlot = {
+  start: Js.Date.t,
+  end: Js.Date.t,
+}
+
 @module("react-big-calendar") @react.component
 external make: (
   ~localizer: 'a,
@@ -37,17 +42,20 @@ external make: (
   ~defaultView: view=?,
   ~views: array<view>=?,
   ~culture: string=?,
+  ~toolbar: bool=?,
+  ~selectable: bool=?,
   ~timeslots: int=?,
   ~min: Js.Date.t=?,
   ~max: Js.Date.t=?,
   ~step: int=?,
   ~components: 'z=?,
-  ~eventPropGetter: eventProp<'b> => eventClassStyle,
+  ~eventPropGetter: eventProp<'b> => eventClassStyle=?,
   ~messages: Js.t<'message>=?,
   ~formats: Js.t<'formats>=?,
   ~onSelectEvent: event<'b> => unit=?,
   ~onView: view => unit=?,
   ~onNavigate: Js.Date.t => unit=?,
+  ~onSelectSlot: timeSlot => unit=?,
 ) => React.element = "Calendar"
 
 type calendarLocalizer