@colisweb/rescript-toolkit 2.13.0 → 2.13.3

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.0",
+  "version": "2.13.3",
   "scripts": {
     "clean": "rescript clean",
     "build": "rescript build",

package/src/logger/Toolkit__BrowserLogger.res

@@ -1,6 +1,15 @@
 open BsSentry
 
-@val @scope("process.env") external nodeEnv: string = "NODE_ENV"
+type t
+@val external windowInstance: option<t> = "window"
+@val external window: t = "window"
+@val external process: t = "import.meta.env"
+let get = () => Js.typeof(windowInstance) !== "undefined" ? window : process
+let instance = get()
+
+@get external _nodeEnv: t => string = "NODE_ENV"
+
+let nodeEnv = instance->_nodeEnv
 
 let debugStyle = "background-color: #208E9C; color: white; padding: 5px; font-size: 10px;"
 let warningStyle = "background-color: #FFAD2D; color: white; padding: 5px; font-size: 10px;"
@@ -19,7 +28,7 @@ let debug2 = (str, str2) => {
 }
 let debug3 = (str, str2, str3) => {
   if nodeEnv !== "production" {
-    Js.Console.logMany(["%cDEBUG", debugStyle, str, str2, str3])
+    Js.Console.logMany(["%cDEBUG", debugStyle, Obj.magic(str), Obj.magic(str2), Obj.magic(str3)])
   }
 }
 
@@ -63,30 +72,3 @@ let error2 = (str, str2) => {
     })
   }
 }
-
-let error3 = (str, str2, str3) => {
-  if nodeEnv !== "production" {
-    Js.Console.logMany(["%cERROR", errorStyle, str, str2, str3])
-  } else {
-    open Sentry
-    withScope(scope => {
-      scope->Scope.setExtra("1-data", str2)
-      scope->Scope.setExtra("2-data", str3)
-      captureMessage(Obj.magic(str))
-    })
-  }
-}
-
-let error4 = (str, str2, str3, str4) => {
-  if nodeEnv !== "production" {
-    Js.Console.logMany(["%cERROR", errorStyle, str, str2, str3, str4])
-  } else {
-    open Sentry
-    withScope(scope => {
-      scope->Scope.setExtra("1-data", str2)
-      scope->Scope.setExtra("2-data", str3)
-      scope->Scope.setExtra("3-data", str4)
-      captureMessage(Obj.magic(str))
-    })
-  }
-}

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/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
-}