@colisweb/rescript-toolkit 2.8.2 → 2.9.0-mobile

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

@@ -0,0 +1,250 @@
+
+
+import * as Cx from "../../../../node_modules/rescript-classnames/lib/es6_global/src/Cx.bs.js";
+import * as Curry from "../../../../node_modules/rescript/lib/es6/curry.js";
+import * as React from "react";
+import * as Reform from "./Reform.bs.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 Caml_option from "../../../../node_modules/rescript/lib/es6/caml_option.js";
+import * as ReSchemaI18n from "../../../../node_modules/reschema/lib/es6_global/src/ReSchemaI18n.bs.js";
+import * as Toolkit__Ui_Label from "../ui/Toolkit__Ui_Label.bs.js";
+import * as Toolkit__Ui_TextInput from "../ui/Toolkit__Ui_TextInput.bs.js";
+import VisuallyHidden from "@reach/visually-hidden";
+
+function handleChange(handleChange$1, $$event) {
+  return Curry._1(handleChange$1, $$event.target.value);
+}
+
+function handleSubmit(handleSubmit$1, $$event) {
+  $$event.preventDefault();
+  return Curry._1(handleSubmit$1, undefined);
+}
+
+var Helpers = {
+  handleChange: handleChange,
+  handleSubmit: handleSubmit
+};
+
+function Toolkit__Form$ErrorMessage(Props) {
+  var error = Props.error;
+  var classNameOpt = Props.className;
+  var className = classNameOpt !== undefined ? classNameOpt : "";
+  if (Belt_Option.isSome(error)) {
+    return React.createElement("p", {
+                className: Cx.cx([
+                      className,
+                      "text-danger-600 text-sm mt-1 form-error-feedback"
+                    ])
+              }, Belt_Option.getExn(error));
+  } else {
+    return null;
+  }
+}
+
+var ErrorMessage = {
+  make: Toolkit__Form$ErrorMessage
+};
+
+function Make(StateLenses) {
+  var include = Reform.Make(StateLenses);
+  var useFormContext = include.useFormContext;
+  var Field = include.Field;
+  var use = include.use;
+  var use$1 = function (initialState, schemaOpt, onSubmit, onSubmitFailOpt, i18nOpt, validationStrategyOpt, param) {
+    var schema = schemaOpt !== undefined ? schemaOpt : /* Schema */({
+          _0: []
+        });
+    var onSubmitFail = onSubmitFailOpt !== undefined ? onSubmitFailOpt : (function (prim) {
+          
+        });
+    var i18n = i18nOpt !== undefined ? i18nOpt : ReSchemaI18n.$$default;
+    var validationStrategy = validationStrategyOpt !== undefined ? validationStrategyOpt : /* OnDemand */1;
+    return Curry._7(use, initialState, schema, (function (form) {
+                  Belt_Option.map(onSubmit, (function (onSubmit) {
+                          return $$Promise.tap(Curry._1(onSubmit, form), (function (x) {
+                                        if (x.TAG === /* Ok */0) {
+                                          return Curry._1(form.send, {
+                                                      TAG: /* SetFormState */9,
+                                                      _0: /* SubmitSucceed */5
+                                                    });
+                                        } else {
+                                          return Curry._1(form.send, {
+                                                      TAG: /* SetFormState */9,
+                                                      _0: /* SubmitFailed */{
+                                                        _0: Caml_option.some(x._0)
+                                                      }
+                                                    });
+                                        }
+                                      }));
+                        }));
+                  
+                }), onSubmitFail, i18n, validationStrategy, undefined);
+  };
+  var Form_ReSchema = include.ReSchema;
+  var Form_Validation = include.Validation;
+  var Form_getInitialFieldsState = include.getInitialFieldsState;
+  var Form_formContext = include.formContext;
+  var Form_useField = include.useField;
+  var Form_Provider = include.Provider;
+  var Form = {
+    ReSchema: Form_ReSchema,
+    Validation: Form_Validation,
+    getInitialFieldsState: Form_getInitialFieldsState,
+    formContext: Form_formContext,
+    useFormContext: useFormContext,
+    useField: Form_useField,
+    Provider: Form_Provider,
+    Field: Field,
+    use: use$1
+  };
+  var Toolkit__Form$Make$Wrapper = function (Props) {
+    var id = Props.id;
+    var className = Props.className;
+    var children = Props.children;
+    var form = Belt_Option.getExn(Curry._1(useFormContext, undefined));
+    var tmp = {
+      onSubmit: (function ($$event) {
+          $$event.preventDefault();
+          return Curry._1(form.submit, undefined);
+        })
+    };
+    if (className !== undefined) {
+      tmp.className = Caml_option.valFromOption(className);
+    }
+    if (id !== undefined) {
+      tmp.id = Caml_option.valFromOption(id);
+    }
+    return React.createElement("form", tmp, children, React.createElement(VisuallyHidden, {
+                    children: React.createElement("input", {
+                          hidden: true,
+                          type: "submit"
+                        })
+                  }));
+  };
+  var Wrapper = {
+    make: Toolkit__Form$Make$Wrapper
+  };
+  var Toolkit__Form$Make$Input = function (Props) {
+    var field = Props.field;
+    var label = Props.label;
+    var id = Props.id;
+    var name = Props.name;
+    var placeholder = Props.placeholder;
+    var autoFocus = Props.autoFocus;
+    var disabled = Props.disabled;
+    var isOptional = Props.isOptional;
+    var type_ = Props.type_;
+    var containerClassNameOpt = Props.containerClassName;
+    var isInlineOpt = Props.isInline;
+    var inputClassNameOpt = Props.inputClassName;
+    var labelClassNameOpt = Props.labelClassName;
+    var inputContainerClassNameOpt = Props.inputContainerClassName;
+    var step = Props.step;
+    var min = Props.min;
+    var max = Props.max;
+    var inputRightAddon = Props.inputRightAddon;
+    var errorClassName = Props.errorClassName;
+    var optionalMessage = Props.optionalMessage;
+    var containerClassName = containerClassNameOpt !== undefined ? containerClassNameOpt : "";
+    var isInline = isInlineOpt !== undefined ? isInlineOpt : false;
+    var inputClassName = inputClassNameOpt !== undefined ? inputClassNameOpt : "";
+    var labelClassName = labelClassNameOpt !== undefined ? labelClassNameOpt : "";
+    var inputContainerClassName = inputContainerClassNameOpt !== undefined ? inputContainerClassNameOpt : "";
+    return React.createElement(Field.make, {
+                field: field,
+                render: (function (param) {
+                    var validate = param.validate;
+                    var state = param.state;
+                    var error = param.error;
+                    var handleChange = param.handleChange;
+                    var isInvalid = Belt_Option.isSome(error);
+                    var onChange = function (param) {
+                      return Curry._1(handleChange, param.target.value);
+                    };
+                    var onBlur = function (param) {
+                      if (state === 0) {
+                        return ;
+                      } else {
+                        return Curry._1(validate, undefined);
+                      }
+                    };
+                    var tmp = {
+                      id: id,
+                      value: param.value,
+                      onBlur: onBlur,
+                      onChange: onChange,
+                      isInvalid: isInvalid,
+                      className: Cx.cx([
+                            inputClassName,
+                            Belt_Option.isSome(inputRightAddon) ? "rounded-r-none" : ""
+                          ])
+                    };
+                    if (name !== undefined) {
+                      tmp.name = name;
+                    }
+                    if (placeholder !== undefined) {
+                      tmp.placeholder = placeholder;
+                    }
+                    if (autoFocus !== undefined) {
+                      tmp.autoFocus = autoFocus;
+                    }
+                    if (disabled !== undefined) {
+                      tmp.disabled = disabled;
+                    }
+                    if (type_ !== undefined) {
+                      tmp.type_ = type_;
+                    }
+                    if (step !== undefined) {
+                      tmp.step = step;
+                    }
+                    if (min !== undefined) {
+                      tmp.min = min;
+                    }
+                    if (max !== undefined) {
+                      tmp.max = max;
+                    }
+                    var tmp$1 = {};
+                    if (error !== undefined) {
+                      tmp$1.error = Caml_option.valFromOption(error);
+                    }
+                    if (errorClassName !== undefined) {
+                      tmp$1.className = Caml_option.valFromOption(errorClassName);
+                    }
+                    return React.createElement(React.Fragment, undefined, React.createElement("div", {
+                                    className: Cx.cx([
+                                          "flex",
+                                          isInline ? "flex-row items-center" : "flex-col",
+                                          containerClassName
+                                        ])
+                                  }, label !== undefined ? React.createElement(Toolkit__Ui_Label.make, {
+                                          htmlFor: id,
+                                          className: labelClassName,
+                                          optionalMessage: Belt_Option.getWithDefault(isOptional, false) ? Belt_Option.getWithDefault(optionalMessage, null) : null,
+                                          children: Caml_option.valFromOption(label)
+                                        }) : null, React.createElement("div", {
+                                        className: Cx.cx([
+                                              "flex flex-row",
+                                              inputContainerClassName
+                                            ])
+                                      }, React.createElement(Toolkit__Ui_TextInput.make, tmp), Belt_Option.getWithDefault(inputRightAddon, null))), React.createElement(Toolkit__Form$ErrorMessage, tmp$1));
+                  })
+              });
+  };
+  var Input = {
+    make: Toolkit__Form$Make$Input
+  };
+  return {
+          Form: Form,
+          Wrapper: Wrapper,
+          Input: Input
+        };
+}
+
+export {
+  Helpers ,
+  ErrorMessage ,
+  Make ,
+  
+}
+/* react Not a pure module */

package/lib/es6_global/src/hooks/Toolkit__Hooks.bs.js

@@ -0,0 +1,307 @@
+
+
+import Swr from "swr";
+import * as Curry from "../../../../node_modules/rescript/lib/es6/curry.js";
+import * as React from "react";
+import * as Browser from "../vendors/Browser.bs.js";
+import * as $$Promise from "../../../../node_modules/reason-promise/lib/es6_global/src/js/promise.bs.js";
+import * as ReactUse from "react-use";
+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 CopyToClipboard from "copy-to-clipboard";
+import * as Toolkit__Ui_Snackbar from "../ui/Toolkit__Ui_Snackbar.bs.js";
+
+function increment(num) {
+  if (num !== 1000000000) {
+    return num + 1 | 0;
+  } else {
+    return -999999999;
+  }
+}
+
+var SafeIncrement = {
+  minInt: -999999999,
+  maxInt: 1000000000,
+  increment: increment
+};
+
+function useIsFirstMount(prim) {
+  return ReactUse.useFirstMountState();
+}
+
+function useUpdateEffect(prim0, prim1) {
+  ReactUse.useUpdateEffect(prim0, prim1);
+  
+}
+
+var useIsMounted = ReactUse.useMountedState;
+
+function useTimeoutFn(prim0, prim1) {
+  return ReactUse.useTimeoutFn(prim0, prim1);
+}
+
+function useDebounce(prim0, prim1, prim2) {
+  return ReactUse.useDebounce(prim0, prim1, prim2);
+}
+
+function useDebounce2(prim0, prim1, prim2) {
+  return ReactUse.useDebounce(prim0, prim1, prim2);
+}
+
+function useDebounce3(prim0, prim1, prim2) {
+  return ReactUse.useDebounce(prim0, prim1, prim2);
+}
+
+function useDebounce4(prim0, prim1, prim2) {
+  return ReactUse.useDebounce(prim0, prim1, prim2);
+}
+
+function useUpdate(param) {
+  var match = React.useState(function () {
+        return 0;
+      });
+  var setState = match[1];
+  return React.useCallback((function (param) {
+                return Curry._1(setState, increment);
+              }), []);
+}
+
+function useGetSet(prim) {
+  return ReactUse.useGetSet(prim);
+}
+
+function usePrevious(prim) {
+  return ReactUse.usePrevious(prim);
+}
+
+function useInitialPrevious(value) {
+  var previousRef = React.useRef(value);
+  React.useEffect(function () {
+        previousRef.current = value;
+        
+      });
+  return previousRef.current;
+}
+
+function usePreviousDistinct(prim0, prim1, prim2) {
+  return ReactUse.usePreviousDistinct(prim0 !== undefined ? Caml_option.valFromOption(prim0) : undefined, prim1);
+}
+
+function useInitialPreviousDistinct(compareOpt, value) {
+  var compare = compareOpt !== undefined ? compareOpt : (function (a, b) {
+        return a === b;
+      });
+  var previousRef = React.useRef(value);
+  var currentRef = React.useRef(value);
+  var isFirstMount = ReactUse.useFirstMountState();
+  if (!isFirstMount && !Curry._2(compare, currentRef.current, value)) {
+    previousRef.current = currentRef.current;
+    currentRef.current = value;
+  }
+  return previousRef.current;
+}
+
+function useFetcher(options, key, fn) {
+  var match = Swr(key, fn, Object.assign(options !== undefined ? Caml_option.valFromOption(options) : ({}), {
+            suspense: true
+          }));
+  var mutate = match.mutate;
+  return [
+          match.data,
+          match.isValidating,
+          (function (param) {
+              return $$Promise.Js.toResult($$Promise.Js.fromBsPromise(mutate()));
+            })
+        ];
+}
+
+function useOptionalFetcher(options, key, fn) {
+  var match = Swr(key, fn, Object.assign(options !== undefined ? Caml_option.valFromOption(options) : ({}), {
+            suspense: true
+          }));
+  var mutate = match.mutate;
+  return [
+          match.data,
+          match.isValidating,
+          (function (param) {
+              return $$Promise.Js.toResult($$Promise.Js.fromBsPromise(mutate()));
+            })
+        ];
+}
+
+function useDisclosure(defaultIsOpen, param) {
+  var match = React.useState(function () {
+        return Belt_Option.getWithDefault(defaultIsOpen, false);
+      });
+  var setIsOpen = match[1];
+  return {
+          isOpen: match[0],
+          show: React.useCallback(function (param) {
+                return Curry._1(setIsOpen, (function (param) {
+                              return true;
+                            }));
+              }),
+          hide: React.useCallback(function (param) {
+                return Curry._1(setIsOpen, (function (param) {
+                              return false;
+                            }));
+              }),
+          toggle: React.useCallback(function (param) {
+                return Curry._1(setIsOpen, (function (isOpen) {
+                              return !isOpen;
+                            }));
+              })
+        };
+}
+
+function useClipboard(onCopyNotificationMessage, value) {
+  var match = React.useState(function () {
+        return false;
+      });
+  var setHasCopied = match[1];
+  var hasCopied = match[0];
+  var onCopy = React.useCallback((function (param) {
+          Belt_Option.forEach(onCopyNotificationMessage, (function (message) {
+                  Toolkit__Ui_Snackbar.show(message, undefined, undefined, "success", undefined, undefined);
+                  
+                }));
+          var didCopy = CopyToClipboard(value);
+          return Curry._1(setHasCopied, (function (param) {
+                        return didCopy;
+                      }));
+        }), [value]);
+  React.useEffect((function () {
+          if (!hasCopied) {
+            return ;
+          }
+          var id = setTimeout((function (param) {
+                  return Curry._1(setHasCopied, (function (param) {
+                                return false;
+                              }));
+                }), 1500);
+          return (function (param) {
+                    clearTimeout(id);
+                    
+                  });
+        }), [hasCopied]);
+  return {
+          value: value,
+          copy: onCopy,
+          hasCopied: hasCopied
+        };
+}
+
+function useRequest(debounceOpt, fn, deps) {
+  var debounce = debounceOpt !== undefined ? debounceOpt : true;
+  var lastCallId = React.useRef(0);
+  var canceled = React.useRef(false);
+  var match = React.useState(function () {
+        return /* NotAsked */0;
+      });
+  var set = match[1];
+  var isMounted = useIsMounted();
+  var trigger = React.useCallback((function (args) {
+          lastCallId.current = increment(lastCallId.current);
+          var callId = lastCallId.current;
+          Curry._1(set, (function (param) {
+                  return /* Loading */1;
+                }));
+          canceled.current = false;
+          return $$Promise.map(Curry._1(fn, args), (function (result) {
+                        var isCanceled = (
+                          debounce ? callId !== lastCallId.current : false
+                        ) || canceled.current;
+                        if (isMounted() && !isCanceled) {
+                          Curry._1(set, (function (param) {
+                                  return /* Done */{
+                                          _0: result
+                                        };
+                                }));
+                        }
+                        return [
+                                result,
+                                isCanceled
+                              ];
+                      }));
+        }), deps);
+  var cancel = React.useCallback((function (param) {
+          canceled.current = true;
+          
+        }), []);
+  return [
+          match[0],
+          trigger,
+          cancel
+        ];
+}
+
+function useMediaQuery(param) {
+  var isXs = React.useMemo((function () {
+          return window.matchMedia("(max-width: 639px)").matches;
+        }), []);
+  var isSm = React.useMemo((function () {
+          return window.matchMedia("(min-width: 640px)").matches;
+        }), []);
+  var isLg = React.useMemo((function () {
+          return window.matchMedia("(min-width: 1024px)").matches;
+        }), []);
+  return {
+          isXs: isXs,
+          isSm: isSm,
+          isLg: isLg
+        };
+}
+
+function useOnClickOutside(ref, handler) {
+  React.useEffect((function () {
+          var listener = function ($$event) {
+            var domRef = ref.current;
+            if (domRef == null) {
+              return ;
+            }
+            var isContentElement = domRef.contains($$event.target);
+            if (isContentElement) {
+              return ;
+            } else {
+              return Curry._1(handler, undefined);
+            }
+          };
+          Browser.$$Document.addEventListener("mousedown", listener);
+          Browser.$$Document.addEventListener("touchstart", listener);
+          return (function (param) {
+                    Browser.$$Document.removeEventListener("mousedown", listener);
+                    return Browser.$$Document.removeEventListener("touchstart", listener);
+                  });
+        }), [
+        ref,
+        handler
+      ]);
+  
+}
+
+export {
+  SafeIncrement ,
+  useIsFirstMount ,
+  useUpdateEffect ,
+  useIsMounted ,
+  useTimeoutFn ,
+  useDebounce ,
+  useDebounce2 ,
+  useDebounce3 ,
+  useDebounce4 ,
+  useUpdate ,
+  useGetSet ,
+  usePrevious ,
+  useInitialPrevious ,
+  usePreviousDistinct ,
+  useInitialPreviousDistinct ,
+  useFetcher ,
+  useOptionalFetcher ,
+  useDisclosure ,
+  useClipboard ,
+  useRequest ,
+  useMediaQuery ,
+  useOnClickOutside ,
+  
+}
+/* useIsMounted Not a pure module */

package/lib/es6_global/src/identifier/Toolkit__Identifier.bs.js

@@ -0,0 +1,50 @@
+
+
+import * as Decco from "../../../../node_modules/decco/lib/es6_global/src/Decco.bs.js";
+
+function MakeString($star) {
+  var t_encode = Decco.stringToJson;
+  var t_decode = Decco.stringFromJson;
+  var Id = {
+    t_encode: t_encode,
+    t_decode: t_decode
+  };
+  var t_encode$1 = Decco.stringToJson;
+  var t_decode$1 = Decco.stringFromJson;
+  return {
+          Id: Id,
+          t_encode: t_encode$1,
+          t_decode: t_decode$1
+        };
+}
+
+function MakeInt($star) {
+  var t_encode = Decco.intToJson;
+  var t_decode = Decco.intFromJson;
+  var Id = {
+    t_encode: t_encode,
+    t_decode: t_decode
+  };
+  var t_encode$1 = Decco.intToJson;
+  var t_decode$1 = Decco.intFromJson;
+  var toString = function (t) {
+    return String(t);
+  };
+  var castAsString = function (t) {
+    return String(t);
+  };
+  return {
+          Id: Id,
+          t_encode: t_encode$1,
+          t_decode: t_decode$1,
+          toString: toString,
+          castAsString: castAsString
+        };
+}
+
+export {
+  MakeString ,
+  MakeInt ,
+  
+}
+/* No side effect */