@colisweb/rescript-toolkit 5.3.5 → 5.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colisweb/rescript-toolkit",
-  "version": "5.3.5",
+  "version": "5.4.0",
   "type": "module",
   "scripts": {
     "clean": "rescript clean",

package/src/form/ReSchema.res

@@ -11,14 +11,15 @@ type childFieldError = {
   name: string,
 }
 
-type fieldState =
+type rec fieldState<'a> =
   | Valid
   | NestedErrors(array<childFieldError>)
+  | NestedErrors2(array<array<('a, fieldState<'a>)>>)
   | Error(string)
 
 type recordValidationState<'a> =
   | Valid
-  | Errors(array<('a, fieldState)>)
+  | Errors(array<('a, fieldState<'a>)>)
 
 module Make = (Lenses: Lenses) => {
   type rec field = Field(Lenses.field<'a>): field
@@ -35,11 +36,15 @@ module Make = (Lenses: Lenses) => {
       | IntMax({field: Lenses.field<int>, max: int, error: option<string>}): t
       | FloatMin({field: Lenses.field<float>, min: float, error: option<string>}): t
       | FloatMax({field: Lenses.field<float>, max: float, error: option<string>}): t
-      | Custom({field: Lenses.field<'a>, predicate: Lenses.state => fieldState}): t
+      | Custom({field: Lenses.field<'a>, predicate: Lenses.state => fieldState<field>}): t
       | CustomNestedSchema({
           field: Lenses.field<'a>,
           predicate: Lenses.state => array<(int, recordValidationState<'a>)>,
         }): t
+      | CustomNestedSchema2({
+          field: Lenses.field<'a>,
+          predicate: Lenses.state => array<array<(field, fieldState<field>)>>,
+        }): t
       | True({field: Lenses.field<bool>, error: option<string>}): t
       | False({field: Lenses.field<bool>, error: option<string>}): t
       | OptionNonEmpty({field: Lenses.field<option<'a>>, error: option<string>}): t
@@ -63,6 +68,9 @@ module Make = (Lenses: Lenses) => {
     let customNestedSchema = (field, predicate) => {
       [CustomNestedSchema({field, predicate})]
     }
+    let customNestedSchema2 = (field, predicate) => {
+      [CustomNestedSchema2({field, predicate})]
+    }
 
     let optionNonEmpty = (~error=?, field) => [OptionNonEmpty({field, error})]
 
@@ -142,7 +150,7 @@ module Make = (Lenses: Lenses) => {
     }
   }
 
-  let validateField = (~validator, ~values, ~i18n: ReSchemaI18n.t): (field, fieldState) =>
+  let validateField = (~validator, ~values, ~i18n: ReSchemaI18n.t): (field, fieldState<field>) =>
     switch validator {
     | Validation.True({field, error}) =>
       let value = Lenses.get(values, field)
@@ -251,6 +259,11 @@ module Make = (Lenses: Lenses) => {
 
         (Field(field)->Obj.magic, errors->Array.length > 0 ? NestedErrors(errors) : Valid)
       }
+    | Validation.CustomNestedSchema2({field, predicate}) => {
+        let results = predicate(values)
+
+        (Field(field), NestedErrors2(results))
+      }
     | Validation.OptionNonEmpty({field, error}) => {
         let value = Lenses.get(values, field)
 
@@ -292,6 +305,7 @@ module Make = (Lenses: Lenses) => {
       | Validation.CustomNestedSchema({field}) => Field(field) == fieldName
       | Validation.OptionNonEmpty({field}) => Field(field) == fieldName
       | Validation.ArrayNonEmpty({field}) => Field(field) == fieldName
+      | Validation.CustomNestedSchema2({field}) => Field(field) == fieldName
       }
     )
 
@@ -312,6 +326,7 @@ module Make = (Lenses: Lenses) => {
       | Validation.StringMax({field}) => Field(field) == fieldName
       | Validation.Custom({field}) => Field(field) == fieldName
       | Validation.CustomNestedSchema({field}) => Field(field) == fieldName
+      | Validation.CustomNestedSchema2({field}) => Field(field) == fieldName
       | Validation.OptionNonEmpty({field}) => Field(field) == fieldName
       | Validation.ArrayNonEmpty({field}) => Field(field) == fieldName
       }
@@ -333,7 +348,12 @@ module Make = (Lenses: Lenses) => {
     })
   }
 
-  let validateFields = (~fields, ~values, ~i18n, schema: Validation.schema) => {
+  let validateFields = (
+    ~fields,
+    ~values,
+    ~i18n=ReSchemaI18n.default,
+    schema: Validation.schema,
+  ) => {
     Belt.Array.map(fields, field =>
       getFieldValidator(~validators=schema, ~fieldName=field)->Belt.Option.map(validator =>
         validateField(~validator, ~values, ~i18n)
@@ -349,10 +369,40 @@ module Make = (Lenses: Lenses) => {
       switch fieldState {
       | Error(_) as e => Some((field, e))
       | NestedErrors(_) as e => Some((field, e))
+      | NestedErrors2(nestedErrors2) as e =>
+        {
+          let rec getIsErrored = nestedErrors2 =>
+            nestedErrors2->Array.some(form => {
+              form->Array.some(
+                ((_, fieldState)) => {
+                  switch fieldState {
+                  | Error(_)
+                  | NestedErrors(_) => true
+                  | NestedErrors2(nextLevel) => getIsErrored(nextLevel)
+                  | _ => false
+                  }
+                },
+              )
+            })
+          getIsErrored(nestedErrors2)
+        }
+          ? Some((field, e))
+          : None
       | _ => None
       }
     )
 
     Belt.Array.length(errors) > 0 ? Errors(errors) : Valid
   }
+
+  let validateAndReturn = (
+    ~i18n=ReSchemaI18n.default,
+    values: Lenses.state,
+    schema: Validation.schema,
+  ) => {
+    let validationList =
+      schema->Belt.Array.map(validator => validateField(~validator, ~values, ~i18n))
+
+    validationList
+  }
 }

package/src/form/Reform.res

@@ -6,13 +6,6 @@ module type Config = {
   type error
 }
 
-type childFieldError = ReSchema.childFieldError
-
-type fieldState =
-  | Pristine
-  | Valid
-  | NestedErrors(array<ReSchema.childFieldError>)
-  | Error(string)
 type formState<'error> =
   | Pristine
   | Dirty
@@ -22,6 +15,8 @@ type formState<'error> =
   | SubmitFailed(option<'error>)
   | SubmitSucceed
 
+type childFieldError = ReSchema.childFieldError
+
 module Make = (Config: Config) => {
   module ReSchema = ReSchema.Make(Config)
   module Validation = ReSchema.Validation
@@ -29,6 +24,15 @@ module Make = (Config: Config) => {
   type field = ReSchema.field
   type formState = formState<Config.error>
 
+  type rec fieldState =
+    | Pristine
+    | Valid
+    | NestedErrors(array<childFieldError>)
+    | NestedErrors2(array<array<(field, fieldState)>>)
+    | Error(string)
+
+  type path = {index: int, subfield: field}
+
   type rec action =
     | ValidateField(field)
     | ValidateForm(bool)
@@ -58,6 +62,7 @@ module Make = (Config: Config) => {
     getFieldState: field => fieldState,
     getFieldError: field => option<string>,
     getNestedFieldError: (field, string, int) => option<string>,
+    getNestedFieldError2: (field, array<path>, ~fieldState: fieldState=?, unit) => option<string>,
     handleChange: 'a. (Config.field<'a>, 'a) => unit,
     arrayPush: 'a. (Config.field<array<'a>>, 'a) => unit,
     arrayUpdateByIndex: 'a. (~field: Config.field<array<'a>>, ~index: int, 'a) => unit,
@@ -113,6 +118,7 @@ module Make = (Config: Config) => {
       | Validation.StringMax({field}) => (Field(field), Pristine)
       | Validation.Custom({field}) => (Field(field), Pristine)
       | Validation.CustomNestedSchema({field}) => (Field(field), Pristine)
+      | Validation.CustomNestedSchema2({field}) => (Field(field), Pristine)
       | Validation.OptionNonEmpty({field}) => (Field(field), Pristine)
       | Validation.ArrayNonEmpty({field}) => (Field(field), Pristine)
       }
@@ -228,6 +234,7 @@ module Make = (Config: Config) => {
                 switch fieldState {
                 | (_, Error(message)) => Error(message)
                 | (_, NestedErrors(errors)) => NestedErrors(errors)
+                | (_, NestedErrors2(errors)) => NestedErrors2(errors->Obj.magic)
                 | (_, Valid) => Valid
                 }
               }
@@ -267,6 +274,7 @@ module Make = (Config: Config) => {
                   switch err {
                   | Error(e) => Error(e)
                   | NestedErrors(e) => NestedErrors(e)
+                  | NestedErrors2(e) => NestedErrors2(e->Obj.magic)
                   | Valid => Valid
                   },
                 ))
@@ -402,13 +410,42 @@ module Make = (Config: Config) => {
         errors
         ->Array.getBy(error => error.index === index && error.name === subfield)
         ->Option.map(({error}) => error)
-
+      | NestedErrors2(_) => None
       | Pristine
       | Valid
       | Error(_) =>
         None
       }
 
+    let rec getNestedFieldError2 = (field, path: array<path>, ~fieldState=?, ()) => {
+      switch fieldState->Option.getWithDefault(getFieldState(field)) {
+      | NestedErrors2(nestedFieldStates) =>
+        nestedFieldStates[(path[0]->Option.getExn).index]->Option.mapWithDefault(None, subform => {
+          let subfield = subform->Array.getBy(((subfield, subfieldState)) => {
+            switch (path, subfield, (path[0]->Option.getExn).subfield, subfieldState) {
+            | ([_], _, _, NestedErrors2(_))
+            | (_, _, _, Valid)
+            | (_, _, _, Pristine) => false
+            | (arr, _, _, Error(_)) if arr->Array.length >= 2 => false
+            | (_, ReSchema.Field(field), ReSchema.Field(field2), _) => field === field2->Obj.magic
+            }
+          })
+
+          switch subfield {
+          | None => getNestedFieldError2(field, [], ~fieldState=Valid, ())
+          | Some((_subfield, subfieldState)) =>
+            getNestedFieldError2(field, path->Array.sliceToEnd(1), ~fieldState=subfieldState, ())
+          }
+        })
+
+      | Pristine
+      | Valid
+      | NestedErrors(_) =>
+        None
+      | Error(err) => Some(err)
+      }
+    }
+
     let validateFields = (fields: array<field>) => {
       let fieldsValidated = ReSchema.validateFields(~fields, ~values=state.values, ~i18n, schema)
 
@@ -432,6 +469,7 @@ module Make = (Config: Config) => {
                   | Valid => [(field, (Valid: fieldState))]
                   | Error(message) => [(field, Error(message))]
                   | NestedErrors(message) => [(field, NestedErrors(message))]
+                  | NestedErrors2(a) => [(field, NestedErrors2(a->Obj.magic))]
                   }
 
                 | None => []
@@ -465,6 +503,7 @@ module Make = (Config: Config) => {
       getFieldState,
       getFieldError,
       getNestedFieldError,
+      getNestedFieldError2,
       handleChange: (field, value) => send(FieldChangeValue(field, value)),
       arrayPush: (field, value) => send(FieldArrayAdd(field, value)),
       arrayUpdateByIndex: (~field, ~index, value) =>

package/src/form/Toolkit__FormValidationFunctions.res

@@ -50,7 +50,7 @@ module Msg = {
   let invalidValue = {defaultMessage: "Valeur non valide."}
 }
 
-let toReSchemaResult = (opt: option<string>): ReSchema.fieldState =>
+let toReSchemaResult = (opt: option<string>): ReSchema.fieldState<'a> =>
   switch opt {
   | Some(e) => Error(e)
   | None => Valid