@colisweb/rescript-toolkit 2.8.2 → 2.9.0-mobile

package/lib/es6_global/src/fetcher/Toolkit__Fetcher.bs.js

@@ -0,0 +1,32 @@
+
+
+import * as Curry from "../../../../node_modules/rescript/lib/es6/curry.js";
+import * as $$Promise from "../../../../node_modules/reason-promise/lib/es6_global/src/js/promise.bs.js";
+import * as Belt_Option from "../../../../node_modules/rescript/lib/es6/belt_Option.js";
+import * as Toolkit__Hooks from "../hooks/Toolkit__Hooks.bs.js";
+
+function Make(Config) {
+  var use = function (options, key) {
+    return Toolkit__Hooks.useFetcher(options, Belt_Option.map(key, Config.key), (function (param) {
+                  var key$1 = Belt_Option.getExn(key);
+                  return $$Promise.Js.fromResult(Curry._1(Config.$$Request.exec, key$1));
+                }));
+  };
+  var useOptional = function (options, key) {
+    return Toolkit__Hooks.useOptionalFetcher(options, Belt_Option.map(key, Config.key), (function (param) {
+                  var key$1 = Belt_Option.getExn(key);
+                  return $$Promise.Js.fromResult(Curry._1(Config.$$Request.exec, key$1));
+                }));
+  };
+  return {
+          key: Config.key,
+          use: use,
+          useOptional: useOptional
+        };
+}
+
+export {
+  Make ,
+  
+}
+/* Promise Not a pure module */

package/lib/es6_global/src/form/Reform.bs.js

@@ -0,0 +1,538 @@
+
+
+import * as Curry from "../../../../node_modules/rescript/lib/es6/curry.js";
+import * as React from "react";
+import * as Caml_obj from "../../../../node_modules/rescript/lib/es6/caml_obj.js";
+import * as ReSchema from "../../../../node_modules/reschema/lib/es6_global/src/ReSchema.bs.js";
+import * as Belt_List from "../../../../node_modules/rescript/lib/es6/belt_List.js";
+import * as Belt_Array from "../../../../node_modules/rescript/lib/es6/belt_Array.js";
+import * as Belt_Option from "../../../../node_modules/rescript/lib/es6/belt_Option.js";
+import * as Caml_option from "../../../../node_modules/rescript/lib/es6/caml_option.js";
+import * as ReactUpdate from "../../../../node_modules/rescript-react-update/lib/es6_global/src/ReactUpdate.bs.js";
+import * as ReSchemaI18n from "../../../../node_modules/reschema/lib/es6_global/src/ReSchemaI18n.bs.js";
+
+function Make(Config) {
+  var ReSchema$1 = ReSchema.Make(Config);
+  var getInitialFieldsState = function (schema) {
+    return Belt_Array.map(schema._0, (function (validator) {
+                  return [
+                          /* Field */{
+                            _0: validator._0
+                          },
+                          /* Pristine */0
+                        ];
+                }));
+  };
+  var formContext = React.createContext(undefined);
+  var useFormContext = function (param) {
+    return React.useContext(formContext);
+  };
+  var useField = function (field) {
+    var $$interface = React.useContext(formContext);
+    return Belt_Option.map($$interface, (function (param) {
+                  var validateField = param.validateField;
+                  return {
+                          handleChange: Curry._1(param.handleChange, field),
+                          error: Curry._1(param.getFieldError, /* Field */{
+                                _0: field
+                              }),
+                          state: Curry._1(param.getFieldState, /* Field */{
+                                _0: field
+                              }),
+                          validate: (function (param) {
+                              return Curry._1(validateField, /* Field */{
+                                          _0: field
+                                        });
+                            }),
+                          value: Curry._2(Config.get, param.state.values, field)
+                        };
+                }));
+  };
+  var makeProps = function (value, children, param) {
+    return {
+            value: Caml_option.some(value),
+            children: children
+          };
+  };
+  var make = formContext.Provider;
+  var Provider = {
+    makeProps: makeProps,
+    make: make
+  };
+  var Reform$Make$Field = function (Props) {
+    var field = Props.field;
+    var render = Props.render;
+    var renderOnMissingContextOpt = Props.renderOnMissingContext;
+    var renderOnMissingContext = renderOnMissingContextOpt !== undefined ? Caml_option.valFromOption(renderOnMissingContextOpt) : null;
+    var fieldInterface = useField(field);
+    return React.useMemo((function () {
+                  return Belt_Option.getWithDefault(Belt_Option.map(fieldInterface, render), renderOnMissingContext);
+                }), [
+                Belt_Option.getWithDefault(Belt_Option.flatMap(fieldInterface, (function (param) {
+                            return param.error;
+                          })), ""),
+                Belt_Option.map(fieldInterface, (function (param) {
+                        return param.value;
+                      })),
+                Belt_Option.map(fieldInterface, (function (param) {
+                        return param.state;
+                      }))
+              ]);
+  };
+  var Field = {
+    make: Reform$Make$Field
+  };
+  var use = function (initialState, schema, onSubmit, onSubmitFailOpt, i18nOpt, validationStrategyOpt, param) {
+    var onSubmitFail = onSubmitFailOpt !== undefined ? onSubmitFailOpt : (function (prim) {
+          
+        });
+    var i18n = i18nOpt !== undefined ? i18nOpt : ReSchemaI18n.$$default;
+    var validationStrategy = validationStrategyOpt !== undefined ? validationStrategyOpt : /* OnChange */0;
+    var match = ReactUpdate.useReducerWithMapState((function (state, action) {
+            if (typeof action === "number") {
+              switch (action) {
+                case /* TrySubmit */0 :
+                    return {
+                            TAG: /* SideEffects */2,
+                            _0: (function (self) {
+                                Curry._1(self.send, {
+                                      TAG: /* ValidateForm */1,
+                                      _0: true
+                                    });
+                                
+                              })
+                          };
+                case /* Submit */1 :
+                    return {
+                            TAG: /* UpdateWithSideEffects */1,
+                            _0: {
+                              formState: /* Submitting */4,
+                              values: state.values,
+                              fieldsState: state.fieldsState
+                            },
+                            _1: (function (self) {
+                                Curry._1(onSubmit, {
+                                      send: self.send,
+                                      state: self.state,
+                                      raiseSubmitFailed: (function (error) {
+                                          return Curry._1(self.send, {
+                                                      TAG: /* RaiseSubmitFailed */12,
+                                                      _0: error
+                                                    });
+                                        })
+                                    });
+                                
+                              })
+                          };
+                case /* ResetForm */2 :
+                    return {
+                            TAG: /* Update */0,
+                            _0: {
+                              formState: /* Pristine */0,
+                              values: initialState,
+                              fieldsState: getInitialFieldsState(schema)
+                            }
+                          };
+                
+              }
+            } else {
+              switch (action.TAG | 0) {
+                case /* ValidateField */0 :
+                    var field = action._0;
+                    return {
+                            TAG: /* SideEffects */2,
+                            _0: (function (self) {
+                                var fieldState = Curry._4(ReSchema$1.validateOne, field, self.state.values, i18n, schema);
+                                var newFieldState = Belt_Option.map(fieldState, (function (x) {
+                                        var message = x[1];
+                                        if (message) {
+                                          return /* Error */{
+                                                  _0: message._0
+                                                };
+                                        } else {
+                                          return /* Valid */1;
+                                        }
+                                      }));
+                                var newFieldsState = Belt_Array.concat(Belt_Array.keep(state.fieldsState, (function (elem) {
+                                            return Caml_obj.caml_notequal(elem[0], field);
+                                          })), newFieldState !== undefined ? [[
+                                          field,
+                                          newFieldState
+                                        ]] : []);
+                                Curry._1(self.send, {
+                                      TAG: /* SetFieldsState */2,
+                                      _0: newFieldsState
+                                    });
+                                
+                              })
+                          };
+                case /* ValidateForm */1 :
+                    var submit = action._0;
+                    return {
+                            TAG: /* SideEffects */2,
+                            _0: (function (self) {
+                                var recordState = Curry._3(ReSchema$1.validate, i18n, self.state.values, schema);
+                                if (recordState) {
+                                  var newFieldsState = Belt_Array.map(recordState._0, (function (param) {
+                                          return [
+                                                  param[0],
+                                                  /* Error */{
+                                                    _0: param[1]
+                                                  }
+                                                ];
+                                        }));
+                                  Curry._1(self.send, {
+                                        TAG: /* SetFieldsState */2,
+                                        _0: newFieldsState
+                                      });
+                                  if (submit) {
+                                    Curry._1(onSubmitFail, {
+                                          send: self.send,
+                                          state: self.state,
+                                          raiseSubmitFailed: (function (error) {
+                                              return Curry._1(self.send, {
+                                                          TAG: /* RaiseSubmitFailed */12,
+                                                          _0: error
+                                                        });
+                                            })
+                                        });
+                                  }
+                                  Curry._1(self.send, {
+                                        TAG: /* SetFormState */9,
+                                        _0: /* Errored */2
+                                      });
+                                } else {
+                                  Curry._1(self.send, {
+                                        TAG: /* SetFormState */9,
+                                        _0: /* Valid */3
+                                      });
+                                  if (submit) {
+                                    Curry._1(self.send, /* Submit */1);
+                                  }
+                                  
+                                }
+                                
+                              })
+                          };
+                case /* SetFieldsState */2 :
+                    return {
+                            TAG: /* Update */0,
+                            _0: {
+                              formState: state.formState,
+                              values: state.values,
+                              fieldsState: action._0
+                            }
+                          };
+                case /* FieldChangeState */3 :
+                    return /* NoUpdate */0;
+                case /* FieldChangeValue */4 :
+                    var field$1 = action._0;
+                    return {
+                            TAG: /* UpdateWithSideEffects */1,
+                            _0: {
+                              formState: state.formState === /* Errored */2 ? /* Errored */2 : /* Dirty */1,
+                              values: Curry._3(Config.set, state.values, field$1, action._1),
+                              fieldsState: state.fieldsState
+                            },
+                            _1: (function (self) {
+                                if (validationStrategy) {
+                                  
+                                } else {
+                                  Curry._1(self.send, {
+                                        TAG: /* ValidateField */0,
+                                        _0: /* Field */{
+                                          _0: field$1
+                                        }
+                                      });
+                                }
+                                
+                              })
+                          };
+                case /* FieldArrayAdd */5 :
+                    var field$2 = action._0;
+                    return {
+                            TAG: /* Update */0,
+                            _0: {
+                              formState: state.formState,
+                              values: Curry._3(Config.set, state.values, field$2, Belt_Array.concat(Curry._2(Config.get, state.values, field$2), [action._1])),
+                              fieldsState: state.fieldsState
+                            }
+                          };
+                case /* FieldArrayUpdateByIndex */6 :
+                    var index = action._2;
+                    var value = action._1;
+                    var field$3 = action._0;
+                    return {
+                            TAG: /* Update */0,
+                            _0: {
+                              formState: state.formState,
+                              values: Curry._3(Config.set, state.values, field$3, Belt_Array.mapWithIndex(Curry._2(Config.get, state.values, field$3), (function (i, currentValue) {
+                                          if (i === index) {
+                                            return value;
+                                          } else {
+                                            return currentValue;
+                                          }
+                                        }))),
+                              fieldsState: state.fieldsState
+                            }
+                          };
+                case /* FieldArrayRemove */7 :
+                    var index$1 = action._1;
+                    var field$4 = action._0;
+                    return {
+                            TAG: /* Update */0,
+                            _0: {
+                              formState: state.formState,
+                              values: Curry._3(Config.set, state.values, field$4, Belt_Array.keepWithIndex(Curry._2(Config.get, state.values, field$4), (function (param, i) {
+                                          return i !== index$1;
+                                        }))),
+                              fieldsState: state.fieldsState
+                            }
+                          };
+                case /* FieldArrayRemoveBy */8 :
+                    var predicate = action._1;
+                    var field$5 = action._0;
+                    return {
+                            TAG: /* Update */0,
+                            _0: {
+                              formState: state.formState,
+                              values: Curry._3(Config.set, state.values, field$5, Belt_Array.keep(Curry._2(Config.get, state.values, field$5), (function (entry) {
+                                          return !Curry._1(predicate, entry);
+                                        }))),
+                              fieldsState: state.fieldsState
+                            }
+                          };
+                case /* SetFormState */9 :
+                    return {
+                            TAG: /* Update */0,
+                            _0: {
+                              formState: action._0,
+                              values: state.values,
+                              fieldsState: state.fieldsState
+                            }
+                          };
+                case /* SetValues */10 :
+                    return {
+                            TAG: /* Update */0,
+                            _0: {
+                              formState: state.formState,
+                              values: action._0,
+                              fieldsState: state.fieldsState
+                            }
+                          };
+                case /* SetFieldValue */11 :
+                    return {
+                            TAG: /* Update */0,
+                            _0: {
+                              formState: state.formState,
+                              values: Curry._3(Config.set, state.values, action._0, action._1),
+                              fieldsState: state.fieldsState
+                            }
+                          };
+                case /* RaiseSubmitFailed */12 :
+                    return {
+                            TAG: /* Update */0,
+                            _0: {
+                              formState: /* SubmitFailed */{
+                                _0: action._0
+                              },
+                              values: state.values,
+                              fieldsState: state.fieldsState
+                            }
+                          };
+                
+              }
+            }
+          }), (function (param) {
+            return {
+                    formState: /* Pristine */0,
+                    values: initialState,
+                    fieldsState: getInitialFieldsState(schema)
+                  };
+          }));
+    var send = match[1];
+    var state = match[0];
+    var getFieldState = function (field) {
+      var field$1 = Belt_List.getBy(Belt_List.fromArray(state.fieldsState), (function (param) {
+              var match = Caml_obj.caml_equal(param[0], field);
+              if (match) {
+                return true;
+              } else {
+                return false;
+              }
+            }));
+      if (field$1 !== undefined) {
+        return field$1[1];
+      } else {
+        return /* Pristine */0;
+      }
+    };
+    var getFieldError = function (field) {
+      var x = getFieldState(field);
+      if (typeof x === "number") {
+        return ;
+      } else {
+        return x._0;
+      }
+    };
+    var validateFields = function (fields) {
+      var fieldsValidated = Curry._4(ReSchema$1.validateFields, fields, state.values, i18n, schema);
+      var newFieldsState = Belt_Array.reduce(Belt_Array.map(state.fieldsState, (function (fieldStateItem) {
+                  var field = fieldStateItem[0];
+                  if (!Belt_Array.some(fields, (function (fieldItem) {
+                            return Caml_obj.caml_equal(fieldItem, field);
+                          }))) {
+                    return [fieldStateItem];
+                  }
+                  var newFieldState = Belt_Array.get(Belt_Array.keep(fieldsValidated, (function (fieldStateValidated) {
+                              return Caml_obj.caml_equal(Belt_Option.map(fieldStateValidated, (function (param) {
+                                                return param[0];
+                                              })), field);
+                            })), 0);
+                  if (newFieldState === undefined) {
+                    return [];
+                  }
+                  var fieldStateValidated = Caml_option.valFromOption(newFieldState);
+                  if (fieldStateValidated === undefined) {
+                    return [];
+                  }
+                  var newFieldStateValidated = fieldStateValidated[1];
+                  if (newFieldStateValidated) {
+                    return [[
+                              field,
+                              /* Error */{
+                                _0: newFieldStateValidated._0
+                              }
+                            ]];
+                  } else {
+                    return [[
+                              field,
+                              /* Valid */1
+                            ]];
+                  }
+                })), [], Belt_Array.concat);
+      Curry._1(send, {
+            TAG: /* SetFieldsState */2,
+            _0: newFieldsState
+          });
+      return Belt_Array.map(Belt_Array.keep(newFieldsState, (function (param) {
+                        var field = param[0];
+                        return Belt_Array.some(fields, (function (fieldItem) {
+                                      return Caml_obj.caml_equal(fieldItem, field);
+                                    }));
+                      })), (function (fieldState) {
+                    return fieldState[1];
+                  }));
+    };
+    var raiseSubmitFailed = function (error) {
+      return Curry._1(send, {
+                  TAG: /* RaiseSubmitFailed */12,
+                  _0: error
+                });
+    };
+    return {
+            state: state,
+            getFieldState: getFieldState,
+            getFieldError: getFieldError,
+            handleChange: (function (field, value) {
+                return Curry._1(send, {
+                            TAG: /* FieldChangeValue */4,
+                            _0: field,
+                            _1: value
+                          });
+              }),
+            arrayPush: (function (field, value) {
+                return Curry._1(send, {
+                            TAG: /* FieldArrayAdd */5,
+                            _0: field,
+                            _1: value
+                          });
+              }),
+            arrayUpdateByIndex: (function (field, index, value) {
+                return Curry._1(send, {
+                            TAG: /* FieldArrayUpdateByIndex */6,
+                            _0: field,
+                            _1: value,
+                            _2: index
+                          });
+              }),
+            arrayRemoveByIndex: (function (field, index) {
+                return Curry._1(send, {
+                            TAG: /* FieldArrayRemove */7,
+                            _0: field,
+                            _1: index
+                          });
+              }),
+            arrayRemoveBy: (function (field, predicate) {
+                return Curry._1(send, {
+                            TAG: /* FieldArrayRemoveBy */8,
+                            _0: field,
+                            _1: predicate
+                          });
+              }),
+            submit: (function (param) {
+                return Curry._1(send, /* TrySubmit */0);
+              }),
+            resetForm: (function (param) {
+                return Curry._1(send, /* ResetForm */2);
+              }),
+            setValues: (function (values) {
+                return Curry._1(send, {
+                            TAG: /* SetValues */10,
+                            _0: values
+                          });
+              }),
+            setFieldValue: (function (field, value, shouldValidateOpt, param) {
+                var shouldValidate = shouldValidateOpt !== undefined ? shouldValidateOpt : true;
+                if (shouldValidate) {
+                  return Curry._1(send, {
+                              TAG: /* FieldChangeValue */4,
+                              _0: field,
+                              _1: value
+                            });
+                } else {
+                  return Curry._1(send, {
+                              TAG: /* SetFieldValue */11,
+                              _0: field,
+                              _1: value
+                            });
+                }
+              }),
+            validateField: (function (field) {
+                return Curry._1(send, {
+                            TAG: /* ValidateField */0,
+                            _0: field
+                          });
+              }),
+            validateForm: (function (param) {
+                return Curry._1(send, {
+                            TAG: /* ValidateForm */1,
+                            _0: false
+                          });
+              }),
+            validateFields: validateFields,
+            raiseSubmitFailed: raiseSubmitFailed,
+            isSubmitting: state.formState === /* Submitting */4,
+            isErrored: state.formState === /* Errored */2,
+            isDirty: state.formState === /* Dirty */1,
+            isValid: state.formState === /* Valid */3
+          };
+  };
+  return {
+          ReSchema: ReSchema$1,
+          Validation: undefined,
+          getInitialFieldsState: getInitialFieldsState,
+          formContext: formContext,
+          useFormContext: useFormContext,
+          useField: useField,
+          Provider: Provider,
+          Field: Field,
+          use: use
+        };
+}
+
+export {
+  Make ,
+  
+}
+/* react Not a pure module */