@colisweb/rescript-toolkit 2.13.1 → 2.13.4

package/bsconfig.json

@@ -26,7 +26,6 @@
     "bs-css",
     "bs-css-emotion",
     "@rescript/react",
-    "bs-axios",
     "reason-promise",
     "reason-react",
     "decco",

package/package.json

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

package/src/request/Toolkit__Request.res

@@ -1,200 +1,12 @@
-type config
-type headers
-type undecodedData
-type failedResponseData
-
-type undecodedResponse = {
-  data: undecodedData,
-  headers: headers,
-  config: config,
-  status: int,
-}
-
-type noResponse = {
-  message: string,
-  config: config,
-}
-
-type rec failedResponse = {
-  message: string,
-  config: config,
-  response: response,
-}
-and response = {
-  data: failedResponseData,
-  headers: headers,
-  status: int,
-}
-
-external castToJs: 'a => Js.t<'b> = "%identity"
-external castToFailedResponse: Js.Promise.error => failedResponse = "%identity"
-external castToNoResponse: Js.Promise.error => noResponse = "%identity"
-external castToUndecodedResponse: Js.t<'a> => undecodedResponse = "%identity"
-
-type error<'a> = [
-  | #noResponse(noResponse)
-  | #invalidResponse(failedResponse)
-  | #invalidResponseData(undecodedResponse, string)
-  | #invalidErrorData
-  | #unknown(Js.Promise.error)
-  | #custom('a)
-]
-
-let toResult = (
-  promise,
-  ~mapError: option<failedResponse => option<result<'data, error<'a>>>>=?,
-  ~errorDecoder=?,
-  mapData: Js.Json.t => result<'data, Decco.decodeError>,
-): Promise.promise<result<'data, error<'error>>> =>
-  promise
-  ->Promise.Js.fromBsPromise
-  ->Promise.Js.toResult
-  ->Promise.map(res =>
-    switch res {
-    | Ok(response) =>
-      switch response["data"]->mapData {
-      | Ok(_) as ok => ok
-      | Error(error) => {
-          Toolkit__BrowserLogger.error2("Decoder failure", error)
-          Error(
-            #invalidResponseData(
-              response->castToUndecodedResponse,
-              "\"" ++ (error.path ++ ("\" " ++ error.message)),
-            ),
-          )
-        }
-      }
-    | Error(error) =>
-      if (error->castToJs)["response"] {
-        switch (mapError, errorDecoder) {
-        | (_, Some(errorDecoder)) =>
-          let error = (error->castToFailedResponse).response.data->Obj.magic->errorDecoder
-
-          switch error {
-          | Ok(err) => Error(#custom(err))
-          | Error(_err) =>
-            Toolkit__BrowserLogger.error2("errorDecoder", _err)
-
-            Error(#invalidErrorData)
-          }
-
-        | (Some(mapError), _) =>
-          switch error->castToFailedResponse->mapError {
-          | None => Error(#invalidResponse(error->castToFailedResponse))
-          | Some(result) => result
-          }
-        | _ => Error(#invalidResponse(error->castToFailedResponse))
-        }
-      } else if (error->castToJs)["request"] {
-        Error(#noResponse(error->castToNoResponse))
-      } else {
-        Error(#unknown(error))
-      }
-    }
-  )
-
-type requestError<'a> = error<'a>
-
 module type Config = {
   type argument
   type response
   type error
-  let exec: argument => Promise.promise<result<response, requestError<error>>>
+  let exec: argument => Promise.promise<
+    result<response, Axios.WithResult.customError<error, Js.Json.t>>,
+  >
 }
 
 module Make = (Config: Config) => {
   include Config
 }
-
-/* Http method */
-
-let get = (
-  request: Axios.Instance.t,
-  url: string,
-  ~mapError: option<failedResponse => option<result<'data, error<'a>>>>=?,
-  ~errorDecoder=?,
-  mapData: Js.Json.t => result<'response, Decco.decodeError>,
-): Promise.promise<result<'response, error<'error>>> =>
-  request->Axios.Instance.get(url)->toResult(~mapError?, ~errorDecoder?, mapData)
-
-let getc = (
-  request: Axios.Instance.t,
-  url: string,
-  ~mapError: option<failedResponse => option<result<'data, error<'a>>>>=?,
-  ~errorDecoder=?,
-  ~config,
-  mapData: Js.Json.t => result<'response, Decco.decodeError>,
-): Promise.promise<result<'response, error<'error>>> =>
-  request->Axios.Instance.getc(url, config)->toResult(~mapError?, ~errorDecoder?, mapData)
-
-let post = (
-  request: Axios.Instance.t,
-  url: string,
-  ~mapError: option<failedResponse => option<result<'data, error<'a>>>>=?,
-  ~errorDecoder=?,
-  mapData: Js.Json.t => result<'response, Decco.decodeError>,
-): Promise.promise<result<'response, error<'error>>> =>
-  request->Axios.Instance.post(url)->toResult(~mapError?, ~errorDecoder?, mapData)
-
-let postData = (
-  request: Axios.Instance.t,
-  url: string,
-  ~mapError: option<failedResponse => option<result<'data, error<'a>>>>=?,
-  ~errorDecoder=?,
-  ~config=?,
-  mapData: Js.Json.t => result<'response, Decco.decodeError>,
-  body: Js.Json.t,
-): Promise.promise<result<'response, error<'error>>> =>
-  switch config {
-  | None =>
-    request
-    ->Axios.Instance.postData(url, body->castToJs)
-    ->toResult(~mapError?, ~errorDecoder?, mapData)
-  | Some(c) =>
-    request
-    ->Axios.Instance.postDatac(url, body->castToJs, c)
-    ->toResult(~mapError?, ~errorDecoder?, mapData)
-  }
-
-let put = (
-  request: Axios.Instance.t,
-  url: string,
-  ~mapError: option<failedResponse => option<result<'data, error<'a>>>>=?,
-  ~errorDecoder=?,
-  mapData: Js.Json.t => result<'response, Decco.decodeError>,
-): Promise.promise<result<'response, error<'error>>> =>
-  request->Axios.Instance.put(url)->toResult(~mapError?, ~errorDecoder?, mapData)
-
-let putData = (
-  request: Axios.Instance.t,
-  url: string,
-  ~mapError: option<failedResponse => option<result<'data, error<'a>>>>=?,
-  ~errorDecoder=?,
-  ~config=?,
-  mapData: Js.Json.t => result<'response, Decco.decodeError>,
-  body: Js.Json.t,
-): Promise.promise<result<'response, error<'error>>> =>
-  switch config {
-  | None =>
-    request
-    ->Axios.Instance.putData(url, body->castToJs)
-    ->toResult(~mapError?, ~errorDecoder?, mapData)
-  | Some(c) =>
-    request
-    ->Axios.Instance.putDatac(url, body->castToJs, c)
-    ->toResult(~mapError?, ~errorDecoder?, mapData)
-  }
-
-let delete = (
-  request: Axios.Instance.t,
-  url: string,
-  ~mapError: option<failedResponse => option<result<'data, error<'a>>>>=?,
-  ~errorDecoder=?,
-  ~config=?,
-  mapData: Js.Json.t => result<'response, Decco.decodeError>,
-): Promise.promise<result<'response, error<'error>>> =>
-  switch config {
-  | None => request->Axios.Instance.delete(url)->toResult(~mapError?, ~errorDecoder?, mapData)
-  | Some(c) =>
-    request->Axios.Instance.deletec(url, c)->toResult(~mapError?, ~errorDecoder?, mapData)
-  }

package/src/router/Toolkit__Router.res

@@ -254,7 +254,7 @@ module Make = (Config: RouterConfig) => {
           <span
             className={cx([
               "transition-all duration-200 ease-in-out absolute ml-12 w-40 transform top-1/2 -translate-y-1/2 text-left",
-              isNavOpen ? "pl-1 opacity-100" : "opacity-0",
+              isNavOpen ? "pl-1 opacity-100 delay-75" : "opacity-0 invisible",
             ])}>
             groupInfo.label
           </span>

package/src/unleash/Toolkit__Unleash.res

@@ -27,7 +27,7 @@ module MakeFeature = (C: Config) => {
   type t = config<C.argument>
 
   let exec = (var: C.input) =>
-    Axios2.get(C.envUrl ++ C.featureName, ())
+    Axios.get(C.envUrl ++ C.featureName, ())
     ->Promise.Js.toResult
     ->Promise.flatMapOk(({data}) => {
       Promise.resolved(t_decode(data))

package/src/vendors/BsReactSelect.res

@@ -127,3 +127,68 @@ module ReactAsyncSelectMultiple = {
     ~loadOptions: string => Promise.Js.t<array<labelOption<'value>>, string>,
   ) => React.element = "default"
 }
+
+module ReactSelectMultipleCreateInput = {
+  module ReactSelect = {
+    type components = {"DropDownIndicator": React.element}
+
+    @module("react-select/creatable") @react.component
+    external make: (
+      ~components: components,
+      ~inputValue: string,
+      ~isClearable: option<bool>=?,
+      ~isMulti: option<bool>=?,
+      ~menuIsOpen: option<bool>=?,
+      ~onChange: array<string> => unit,
+      ~onInputChange: string => unit,
+      ~onKeyDown: ReactEvent.Keyboard.t => unit,
+      ~placeholder: option<string>=?,
+      ~value: array<string>,
+      ~isDisabled: option<bool>=?,
+      ~isLoading: option<bool>=?,
+      ~className: option<string>=?,
+    ) => React.element = "CreatableSelect"
+  }
+
+  @react.component
+  let make = (
+    ~inputValue: string,
+    ~onInputChange: string => unit,
+    ~value: array<string>,
+    ~onChange: array<string> => unit,
+    ~isClearable=true,
+    ~placeholder="",
+    ~isDisabled=false,
+    ~isLoading=false,
+    ~className="",
+  ) =>
+    <ReactSelect
+      components={"DropDownIndicator": React.null}
+      isMulti=true
+      onKeyDown={e => {
+        if inputValue === "" {
+          ()
+        } else {
+          switch e->ReactEvent.Keyboard.key {
+          | "Enter"
+          | "Tab" => {
+              onInputChange("")
+              onChange(value->Array.concat([inputValue]))
+              e->ReactEvent.Keyboard.preventDefault
+            }
+          | _ => ()
+          }
+        }
+      }}
+      menuIsOpen={false}
+      inputValue
+      isClearable
+      onChange
+      onInputChange
+      placeholder
+      value
+      isDisabled
+      isLoading
+      className
+    />
+}

package/src/fetcher/Toolkit__Fetcher2.res

@@ -1,28 +0,0 @@
-module type Config = {
-  module Request: Toolkit__Request2.Config
-  let key: Request.argument => array<string>
-}
-
-module Make = (Config: Config) => {
-  let key: Config.Request.argument => array<string> = Config.key
-
-  let use = (
-    ~options: option<Swr.fetcherOptions>=?,
-    key: option<Config.Request.argument>,
-  ): Toolkit__Hooks.fetcher<Config.Request.response> =>
-    Toolkit__Hooks.useFetcher(~options?, key->Option.map(Config.key), () => {
-      let key = key->Option.getExn
-
-      Config.Request.exec(key)->Promise.Js.fromResult
-    })
-
-  let useOptional = (
-    ~options: option<Swr.fetcherOptions>=?,
-    key: option<Config.Request.argument>,
-  ): Toolkit__Hooks.fetcher<option<Config.Request.response>> =>
-    Toolkit__Hooks.useOptionalFetcher(~options?, key->Option.map(Config.key), () => {
-      let key = key->Option.getExn
-
-      Config.Request.exec(key)->Promise.Js.fromResult
-    })
-}

package/src/request/Toolkit__Request2.res

@@ -1,12 +0,0 @@
-module type Config = {
-  type argument
-  type response
-  type error
-  let exec: argument => Promise.promise<
-    result<response, Axios2.WithResult.customError<error, Js.Json.t>>,
-  >
-}
-
-module Make = (Config: Config) => {
-  include Config
-}