@plowtech/rescript-fetch 0.5.2 → 0.6.0

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@plowtech/rescript-fetch",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "ReScript Bindings for the Fetch API",
   "main": "index.js",
   "scripts": {
-    "test": "retest --with-dom tests/*.res.js",
     "res:build": "rescript",
     "res:dev": "rescript -w",
     "res:clean": "rescript clean"
@@ -23,16 +22,6 @@
   },
   "homepage": "https://github.com/plow-technologies/rescript-fetch#readme",
   "dependencies": {
-    "@rescript/core": "^1.5.2",
-    "rescript": "^11.1.3"
-  },
-  "devDependencies": {
-    "@rescript/react": "^0.13.0",
-    "@testing-library/dom": "^10.4.0",
-    "@testing-library/react": "^16.0.0",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "rescript-test": "^7.0.1",
-    "rescript-webapi": "^0.9.1"
+    "rescript": "^12.1.0"
   }
 }

package/rescript.json

@@ -4,11 +4,6 @@
     {
       "dir": "src",
       "subdirs": true
-    },
-    {
-      "dir": "tests",
-      "subdirs": true,
-      "type": "dev"
     }
   ],
   "package-specs": [
@@ -17,19 +12,5 @@
       "in-source": true
     }
   ],
-  "suffix": ".res.js",
-  "bs-dependencies": [
-    "@rescript/core",
-    "@rescript/react"
-  ],
-  "bs-dev-dependencies": [
-    "rescript-test",
-    "rescript-webapi"
-  ],
-  "bsc-flags": [
-    "-open RescriptCore"
-  ],
-  "jsx": {
-    "version": 4
-  }
+  "suffix": ".res.js"
 }

package/src/Fetch.res

@@ -114,7 +114,7 @@ let decodeReferrerPolicy = (referrerPolicy: string) =>
   | "origin-when-cross-origin" => OriginWhenCrossOrigin
   | "strict-origin-when-cross-origin" => StrictOriginWhenCrossOrigin
   | "unsafe-url" => UnsafeUrl
-  | e => raise(UnknownReferrerPolicy(e))
+  | e => throw(UnknownReferrerPolicy(e))
   }
 
 type requestType =
@@ -139,7 +139,7 @@ let decodeRequestType = (requestType: string) =>
   | "style" => Style
   | "track" => Track
   | "video" => Video
-  | e => raise(UnknownRequestType(e))
+  | e => throw(UnknownRequestType(e))
   }
 
 type requestDestination =
@@ -178,7 +178,7 @@ let decodeRequestDestination = (requestDestination: string) =>
   | "style" => Style
   | "worker" => Worker
   | "xslt" => Xslt
-  | e => raise(UnknownRequestDestination(e))
+  | e => throw(UnknownRequestDestination(e))
   }
 
 type requestMode =
@@ -203,7 +203,7 @@ let decodeRequestMode = (requestMode: string) =>
   | "same-origin" => SameOrigin
   | "no-cors" => NoCORS
   | "cors" => CORS
-  | e => raise(UnknownRequestMode(e))
+  | e => throw(UnknownRequestMode(e))
   }
 
 type requestCredentials =
@@ -225,7 +225,7 @@ let decodeRequestCredentials = (requestCredentials: string) =>
   | "omit" => Omit
   | "same-origin" => SameOrigin
   | "include" => Include
-  | e => raise(UnknownRequestCredentials(e))
+  | e => throw(UnknownRequestCredentials(e))
   }
 
 type requestCache =
@@ -256,7 +256,7 @@ let decodeRequestCache = (requestCache: string) =>
   | "no-cache" => NoCache
   | "force-cache" => ForceCache
   | "only-if-cached" => OnlyIfCached
-  | e => raise(UnknownRequestCache(e))
+  | e => throw(UnknownRequestCache(e))
   }
 
 type requestRedirect =
@@ -278,14 +278,14 @@ let decodeRequestRedirect = (requestRedirect: string) =>
   | "follow" => Follow
   | "error" => Error
   | "manual" => Manual
-  | e => raise(UnknownRequestRedirect(e))
+  | e => throw(UnknownRequestRedirect(e))
   }
 
 module HeadersInit = {
   type t = headersInit
 
-  external make: Js.t<{..}> => t = "%identity"
-  external makeWithDict: Js.Dict.t<string> => t = "%identity"
+  external make: {..} => t = "%identity"
+  external makeWithDict: dict<string> => t = "%identity"
   external makeWithArray: array<(string, string)> => t = "%identity"
 }
 
@@ -334,19 +334,19 @@ module Body = {
   external bodyUsed: t => bool = "bodyUsed"
 
   @send
-  external arrayBuffer: t => Js.Promise.t<arrayBuffer> = "arrayBuffer"
+  external arrayBuffer: t => promise<arrayBuffer> = "arrayBuffer"
 
   @send
-  external blob: t => Js.Promise.t<blob> = "blob"
+  external blob: t => promise<blob> = "blob"
 
   @send
-  external formData: t => Js.Promise.t<formData> = "formData"
+  external formData: t => promise<formData> = "formData"
 
   @send
-  external json: t => Js.Promise.t<Js.Json.t> = "json"
+  external json: t => promise<JSON.t> = "json"
 
   @send
-  external text: t => Js.Promise.t<string> = "text"
+  external text: t => promise<string> = "text"
 }
 
 module RequestInit = {
@@ -473,19 +473,19 @@ module Request = {
   external bodyUsed: t => bool = "bodyUsed"
 
   @send
-  external arrayBuffer: t => Js.Promise.t<arrayBuffer> = "arrayBuffer"
+  external arrayBuffer: t => promise<arrayBuffer> = "arrayBuffer"
 
   @send
-  external blob: t => Js.Promise.t<blob> = "blob"
+  external blob: t => promise<blob> = "blob"
 
   @send
-  external formData: t => Js.Promise.t<formData> = "formData"
+  external formData: t => promise<formData> = "formData"
 
   @send
-  external json: t => Js.Promise.t<Js.Json.t> = "json"
+  external json: t => promise<JSON.t> = "json"
 
   @send
-  external text: t => Js.Promise.t<string> = "text"
+  external text: t => promise<string> = "text"
 }
 
 module Response = {
@@ -533,29 +533,29 @@ module Response = {
   external bodyUsed: t => bool = "bodyUsed"
 
   @send
-  external arrayBuffer: t => Js.Promise.t<arrayBuffer> = "arrayBuffer"
+  external arrayBuffer: t => promise<arrayBuffer> = "arrayBuffer"
 
   @send
-  external blob: t => Js.Promise.t<blob> = "blob"
+  external blob: t => promise<blob> = "blob"
 
   @send
-  external formData: t => Js.Promise.t<formData> = "formData"
+  external formData: t => promise<formData> = "formData"
 
   @send
-  external json: t => Js.Promise.t<Js.Json.t> = "json"
+  external json: t => promise<JSON.t> = "json"
 
   @send
-  external text: t => Js.Promise.t<string> = "text"
+  external text: t => promise<string> = "text"
 }
 
 @val
-external fetch: string => Js.Promise.t<response> = "fetch"
+external fetch: string => promise<response> = "fetch"
 
 @val
-external fetchWithInit: (string, requestInit) => Js.Promise.t<response> = "fetch"
+external fetchWithInit: (string, requestInit) => promise<response> = "fetch"
 
 @val
-external fetchWithRequest: request => Js.Promise.t<response> = "fetch"
+external fetchWithRequest: request => promise<response> = "fetch"
 
 @val
-external fetchWithRequestInit: (request, requestInit) => Js.Promise.t<response> = "fetch"
+external fetchWithRequestInit: (request, requestInit) => promise<response> = "fetch"

package/src/Fetch.res.js

@@ -1,9 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 'use strict';
 
-var Caml_option = require("rescript/lib/js/caml_option.js");
-var Core__Option = require("@rescript/core/src/Core__Option.res.js");
-var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
+let Stdlib_Option = require("@rescript/runtime/lib/js/Stdlib_Option.js");
+let Primitive_option = require("@rescript/runtime/lib/js/Primitive_option.js");
+let Primitive_exceptions = require("@rescript/runtime/lib/js/Primitive_exceptions.js");
 
 function encodeRequestMethod(requestMethod) {
   if (typeof requestMethod === "object") {
@@ -11,163 +11,157 @@ function encodeRequestMethod(requestMethod) {
   }
   switch (requestMethod) {
     case "Get" :
-        return "GET";
+      return "GET";
     case "Head" :
-        return "HEAD";
+      return "HEAD";
     case "Post" :
-        return "POST";
+      return "POST";
     case "Put" :
-        return "PUT";
+      return "PUT";
     case "Delete" :
-        return "DELETE";
+      return "DELETE";
     case "Connect" :
-        return "CONNECT";
+      return "CONNECT";
     case "Options" :
-        return "OPTIONS";
+      return "OPTIONS";
     case "Trace" :
-        return "TRACE";
+      return "TRACE";
     case "Patch" :
-        return "PATCH";
-    
+      return "PATCH";
   }
 }
 
-var $$AbortController = {};
+let AbortController = {};
 
 function encodeReferrerPolicy(referrerPolicy) {
   switch (referrerPolicy) {
     case "None" :
-        return "";
+      return "";
     case "NoReferrer" :
-        return "no-referrer";
+      return "no-referrer";
     case "NoReferrerWhenDowngrade" :
-        return "no-referrer-when-downgrade";
+      return "no-referrer-when-downgrade";
     case "SameOrigin" :
-        return "same-origin";
+      return "same-origin";
     case "Origin" :
-        return "origin";
+      return "origin";
     case "StrictOrigin" :
-        return "strict-origin";
+      return "strict-origin";
     case "OriginWhenCrossOrigin" :
-        return "origin-when-cross-origin";
+      return "origin-when-cross-origin";
     case "StrictOriginWhenCrossOrigin" :
-        return "strict-origin-when-cross-origin";
+      return "strict-origin-when-cross-origin";
     case "UnsafeUrl" :
-        return "unsafe-url";
-    
+      return "unsafe-url";
   }
 }
 
-var UnknownReferrerPolicy = /* @__PURE__ */Caml_exceptions.create("Fetch.UnknownReferrerPolicy");
+let UnknownReferrerPolicy = /* @__PURE__ */Primitive_exceptions.create("Fetch.UnknownReferrerPolicy");
 
-var UnknownRequestType = /* @__PURE__ */Caml_exceptions.create("Fetch.UnknownRequestType");
+let UnknownRequestType = /* @__PURE__ */Primitive_exceptions.create("Fetch.UnknownRequestType");
 
-var UnknownRequestDestination = /* @__PURE__ */Caml_exceptions.create("Fetch.UnknownRequestDestination");
+let UnknownRequestDestination = /* @__PURE__ */Primitive_exceptions.create("Fetch.UnknownRequestDestination");
 
 function encodeRequestMode(requestMode) {
   switch (requestMode) {
     case "Navigate" :
-        return "navigate";
+      return "navigate";
     case "SameOrigin" :
-        return "same-origin";
+      return "same-origin";
     case "NoCORS" :
-        return "no-cors";
+      return "no-cors";
     case "CORS" :
-        return "cors";
-    
+      return "cors";
   }
 }
 
-var UnknownRequestMode = /* @__PURE__ */Caml_exceptions.create("Fetch.UnknownRequestMode");
+let UnknownRequestMode = /* @__PURE__ */Primitive_exceptions.create("Fetch.UnknownRequestMode");
 
 function encodeRequestCredentials(requestCredentials) {
   switch (requestCredentials) {
     case "Omit" :
-        return "omit";
+      return "omit";
     case "SameOrigin" :
-        return "same-origin";
+      return "same-origin";
     case "Include" :
-        return "include";
-    
+      return "include";
   }
 }
 
-var UnknownRequestCredentials = /* @__PURE__ */Caml_exceptions.create("Fetch.UnknownRequestCredentials");
+let UnknownRequestCredentials = /* @__PURE__ */Primitive_exceptions.create("Fetch.UnknownRequestCredentials");
 
 function encodeRequestCache(requestCache) {
   switch (requestCache) {
     case "Default" :
-        return "default";
+      return "default";
     case "NoStore" :
-        return "no-store";
+      return "no-store";
     case "Reload" :
-        return "reload";
+      return "reload";
     case "NoCache" :
-        return "no-cache";
+      return "no-cache";
     case "ForceCache" :
-        return "force-cache";
+      return "force-cache";
     case "OnlyIfCached" :
-        return "only-if-cached";
-    
+      return "only-if-cached";
   }
 }
 
-var UnknownRequestCache = /* @__PURE__ */Caml_exceptions.create("Fetch.UnknownRequestCache");
+let UnknownRequestCache = /* @__PURE__ */Primitive_exceptions.create("Fetch.UnknownRequestCache");
 
 function encodeRequestRedirect(requestRedirect) {
   switch (requestRedirect) {
     case "Follow" :
-        return "follow";
+      return "follow";
     case "Error" :
-        return "error";
+      return "error";
     case "Manual" :
-        return "manual";
-    
+      return "manual";
   }
 }
 
-var UnknownRequestRedirect = /* @__PURE__ */Caml_exceptions.create("Fetch.UnknownRequestRedirect");
+let UnknownRequestRedirect = /* @__PURE__ */Primitive_exceptions.create("Fetch.UnknownRequestRedirect");
 
-var HeadersInit = {};
+let HeadersInit = {};
 
-var $$Headers = {};
+let Headers = {};
 
-var BodyInit = {};
+let BodyInit = {};
 
-var Body = {};
+let Body = {};
 
 function make(method_, headers, body, referrer, referrerPolicy, mode, credentials, cache, redirect, integrity, keepalive, signal, param) {
-  var tmp = {};
-  var tmp$1 = Core__Option.map(method_, encodeRequestMethod);
+  let tmp = {};
+  let tmp$1 = Stdlib_Option.map(method_, encodeRequestMethod);
   if (tmp$1 !== undefined) {
     tmp.method = tmp$1;
   }
   if (headers !== undefined) {
-    tmp.headers = Caml_option.valFromOption(headers);
+    tmp.headers = Primitive_option.valFromOption(headers);
   }
   if (body !== undefined) {
-    tmp.body = Caml_option.valFromOption(body);
+    tmp.body = Primitive_option.valFromOption(body);
   }
   if (referrer !== undefined) {
     tmp.referrer = referrer;
   }
-  var tmp$2 = Core__Option.map(referrerPolicy, encodeReferrerPolicy);
+  let tmp$2 = Stdlib_Option.map(referrerPolicy, encodeReferrerPolicy);
   if (tmp$2 !== undefined) {
     tmp.referrerPolicy = tmp$2;
   }
-  var tmp$3 = Core__Option.map(mode, encodeRequestMode);
+  let tmp$3 = Stdlib_Option.map(mode, encodeRequestMode);
   if (tmp$3 !== undefined) {
     tmp.mode = tmp$3;
   }
-  var tmp$4 = Core__Option.map(credentials, encodeRequestCredentials);
+  let tmp$4 = Stdlib_Option.map(credentials, encodeRequestCredentials);
   if (tmp$4 !== undefined) {
     tmp.credentials = tmp$4;
   }
-  var tmp$5 = Core__Option.map(cache, encodeRequestCache);
+  let tmp$5 = Stdlib_Option.map(cache, encodeRequestCache);
   if (tmp$5 !== undefined) {
     tmp.cache = tmp$5;
   }
-  var tmp$6 = Core__Option.map(redirect, encodeRequestRedirect);
+  let tmp$6 = Stdlib_Option.map(redirect, encodeRequestRedirect);
   if (tmp$6 !== undefined) {
     tmp.redirect = tmp$6;
   }
@@ -178,225 +172,225 @@ function make(method_, headers, body, referrer, referrerPolicy, mode, credential
     tmp.keepalive = keepalive;
   }
   if (signal !== undefined) {
-    tmp.signal = Caml_option.valFromOption(signal);
+    tmp.signal = Primitive_option.valFromOption(signal);
   }
   return tmp;
 }
 
-var RequestInit = {
+let RequestInit = {
   make: make
 };
 
 function method_(self) {
-  var requestMethod = self.method;
+  let requestMethod = self.method;
   switch (requestMethod) {
     case "CONNECT" :
-        return "Connect";
+      return "Connect";
     case "DELETE" :
-        return "Delete";
+      return "Delete";
     case "GET" :
-        return "Get";
+      return "Get";
     case "HEAD" :
-        return "Head";
+      return "Head";
     case "OPTIONS" :
-        return "Options";
+      return "Options";
     case "PATCH" :
-        return "Patch";
+      return "Patch";
     case "POST" :
-        return "Post";
+      return "Post";
     case "PUT" :
-        return "Put";
+      return "Put";
     case "TRACE" :
-        return "Trace";
+      return "Trace";
     default:
       return {
-              TAG: "Other",
-              _0: requestMethod
-            };
+        TAG: "Other",
+        _0: requestMethod
+      };
   }
 }
 
 function type_(self) {
-  var requestType = self.type;
+  let requestType = self.type;
   switch (requestType) {
     case "" :
-        return "None";
+      return "None";
     case "audio" :
-        return "Audio";
+      return "Audio";
     case "font" :
-        return "Font";
+      return "Font";
     case "image" :
-        return "Image";
+      return "Image";
     case "script" :
-        return "Script";
+      return "Script";
     case "style" :
-        return "Style";
+      return "Style";
     case "track" :
-        return "Track";
+      return "Track";
     case "video" :
-        return "Video";
+      return "Video";
     default:
       throw {
-            RE_EXN_ID: UnknownRequestType,
-            _1: requestType,
-            Error: new Error()
-          };
+        RE_EXN_ID: UnknownRequestType,
+        _1: requestType,
+        Error: new Error()
+      };
   }
 }
 
 function destination(self) {
-  var requestDestination = self.destination;
+  let requestDestination = self.destination;
   switch (requestDestination) {
     case "" :
-        return "None";
+      return "None";
     case "document" :
-        return "Document";
+      return "Document";
     case "embed" :
-        return "Embed";
+      return "Embed";
     case "font" :
-        return "Font";
+      return "Font";
     case "image" :
-        return "Image";
+      return "Image";
     case "manifest" :
-        return "Manifest";
+      return "Manifest";
     case "media" :
-        return "Media";
+      return "Media";
     case "object" :
-        return "Object";
+      return "Object";
     case "report" :
-        return "Report";
+      return "Report";
     case "script" :
-        return "Script";
+      return "Script";
     case "serviceworker" :
-        return "ServiceWorker";
+      return "ServiceWorker";
     case "sharedworker" :
-        return "SharedWorker";
+      return "SharedWorker";
     case "style" :
-        return "Style";
+      return "Style";
     case "worker" :
-        return "Worker";
+      return "Worker";
     case "xslt" :
-        return "Xslt";
+      return "Xslt";
     default:
       throw {
-            RE_EXN_ID: UnknownRequestDestination,
-            _1: requestDestination,
-            Error: new Error()
-          };
+        RE_EXN_ID: UnknownRequestDestination,
+        _1: requestDestination,
+        Error: new Error()
+      };
   }
 }
 
 function referrerPolicy(self) {
-  var referrerPolicy$1 = self.referrerPolicy;
+  let referrerPolicy$1 = self.referrerPolicy;
   switch (referrerPolicy$1) {
     case "" :
-        return "None";
+      return "None";
     case "no-referrer" :
-        return "NoReferrer";
+      return "NoReferrer";
     case "no-referrer-when-downgrade" :
-        return "NoReferrerWhenDowngrade";
+      return "NoReferrerWhenDowngrade";
     case "origin" :
-        return "Origin";
+      return "Origin";
     case "origin-when-cross-origin" :
-        return "OriginWhenCrossOrigin";
+      return "OriginWhenCrossOrigin";
     case "same-origin" :
-        return "SameOrigin";
+      return "SameOrigin";
     case "strict-origin" :
-        return "StrictOrigin";
+      return "StrictOrigin";
     case "strict-origin-when-cross-origin" :
-        return "StrictOriginWhenCrossOrigin";
+      return "StrictOriginWhenCrossOrigin";
     case "unsafe-url" :
-        return "UnsafeUrl";
+      return "UnsafeUrl";
     default:
       throw {
-            RE_EXN_ID: UnknownReferrerPolicy,
-            _1: referrerPolicy$1,
-            Error: new Error()
-          };
+        RE_EXN_ID: UnknownReferrerPolicy,
+        _1: referrerPolicy$1,
+        Error: new Error()
+      };
   }
 }
 
 function mode(self) {
-  var requestMode = self.mode;
+  let requestMode = self.mode;
   switch (requestMode) {
     case "cors" :
-        return "CORS";
+      return "CORS";
     case "navigate" :
-        return "Navigate";
+      return "Navigate";
     case "no-cors" :
-        return "NoCORS";
+      return "NoCORS";
     case "same-origin" :
-        return "SameOrigin";
+      return "SameOrigin";
     default:
       throw {
-            RE_EXN_ID: UnknownRequestMode,
-            _1: requestMode,
-            Error: new Error()
-          };
+        RE_EXN_ID: UnknownRequestMode,
+        _1: requestMode,
+        Error: new Error()
+      };
   }
 }
 
 function credentials(self) {
-  var requestCredentials = self.credentials;
+  let requestCredentials = self.credentials;
   switch (requestCredentials) {
     case "include" :
-        return "Include";
+      return "Include";
     case "omit" :
-        return "Omit";
+      return "Omit";
     case "same-origin" :
-        return "SameOrigin";
+      return "SameOrigin";
     default:
       throw {
-            RE_EXN_ID: UnknownRequestCredentials,
-            _1: requestCredentials,
-            Error: new Error()
-          };
+        RE_EXN_ID: UnknownRequestCredentials,
+        _1: requestCredentials,
+        Error: new Error()
+      };
   }
 }
 
 function cache(self) {
-  var requestCache = self.cache;
+  let requestCache = self.cache;
   switch (requestCache) {
     case "default" :
-        return "Default";
+      return "Default";
     case "force-cache" :
-        return "ForceCache";
+      return "ForceCache";
     case "no-cache" :
-        return "NoCache";
+      return "NoCache";
     case "no-store" :
-        return "NoStore";
+      return "NoStore";
     case "only-if-cached" :
-        return "OnlyIfCached";
+      return "OnlyIfCached";
     case "reload" :
-        return "Reload";
+      return "Reload";
     default:
       throw {
-            RE_EXN_ID: UnknownRequestCache,
-            _1: requestCache,
-            Error: new Error()
-          };
+        RE_EXN_ID: UnknownRequestCache,
+        _1: requestCache,
+        Error: new Error()
+      };
   }
 }
 
 function redirect(self) {
-  var requestRedirect = self.redirect;
+  let requestRedirect = self.redirect;
   switch (requestRedirect) {
     case "error" :
-        return "Error";
+      return "Error";
     case "follow" :
-        return "Follow";
+      return "Follow";
     case "manual" :
-        return "Manual";
+      return "Manual";
     default:
       throw {
-            RE_EXN_ID: UnknownRequestRedirect,
-            _1: requestRedirect,
-            Error: new Error()
-          };
+        RE_EXN_ID: UnknownRequestRedirect,
+        _1: requestRedirect,
+        Error: new Error()
+      };
   }
 }
 
-var $$Request = {
+let Request = {
   method_: method_,
   type_: type_,
   destination: destination,
@@ -407,14 +401,14 @@ var $$Request = {
   redirect: redirect
 };
 
-var $$Response = {};
+let Response = {};
 
-exports.$$AbortController = $$AbortController;
+exports.AbortController = AbortController;
 exports.HeadersInit = HeadersInit;
-exports.$$Headers = $$Headers;
+exports.Headers = Headers;
 exports.BodyInit = BodyInit;
 exports.Body = Body;
 exports.RequestInit = RequestInit;
-exports.$$Request = $$Request;
-exports.$$Response = $$Response;
+exports.Request = Request;
+exports.Response = Response;
 /* No side effect */

package/src/Fetch.resi

@@ -110,8 +110,8 @@ type requestRedirect =
 module HeadersInit: {
   type t = headersInit
 
-  external make: Js.t<{..}> => t = "%identity"
-  external makeWithDict: Js.Dict.t<string> => t = "%identity"
+  external make: {..} => t = "%identity"
+  external makeWithDict: dict<string> => t = "%identity"
   external makeWithArray: array<(string, string)> => t = "%identity"
 }
 
@@ -160,19 +160,19 @@ module Body: {
   external bodyUsed: t => bool = "bodyUsed"
 
   @send
-  external arrayBuffer: t => Js.Promise.t<arrayBuffer> = "arrayBuffer"
+  external arrayBuffer: t => promise<arrayBuffer> = "arrayBuffer"
 
   @send
-  external blob: t => Js.Promise.t<blob> = "blob"
+  external blob: t => promise<blob> = "blob"
 
   @send
-  external formData: t => Js.Promise.t<formData> = "formData"
+  external formData: t => promise<formData> = "formData"
 
   @send
-  external json: t => Js.Promise.t<Js.Json.t> = "json"
+  external json: t => promise<JSON.t> = "json"
 
   @send
-  external text: t => Js.Promise.t<string> = "text"
+  external text: t => promise<string> = "text"
 }
 
 module RequestInit: {
@@ -249,19 +249,19 @@ module Request: {
   external bodyUsed: t => bool = "bodyUsed"
 
   @send
-  external arrayBuffer: t => Js.Promise.t<arrayBuffer> = "arrayBuffer"
+  external arrayBuffer: t => promise<arrayBuffer> = "arrayBuffer"
 
   @send
-  external blob: t => Js.Promise.t<blob> = "blob"
+  external blob: t => promise<blob> = "blob"
 
   @send
-  external formData: t => Js.Promise.t<formData> = "formData"
+  external formData: t => promise<formData> = "formData"
 
   @send
-  external json: t => Js.Promise.t<Js.Json.t> = "json"
+  external json: t => promise<JSON.t> = "json"
 
   @send
-  external text: t => Js.Promise.t<string> = "text"
+  external text: t => promise<string> = "text"
 }
 
 module Response: {
@@ -309,29 +309,29 @@ module Response: {
   external bodyUsed: t => bool = "bodyUsed"
 
   @send
-  external arrayBuffer: t => Js.Promise.t<arrayBuffer> = "arrayBuffer"
+  external arrayBuffer: t => promise<arrayBuffer> = "arrayBuffer"
 
   @send
-  external blob: t => Js.Promise.t<blob> = "blob"
+  external blob: t => promise<blob> = "blob"
 
   @send
-  external formData: t => Js.Promise.t<formData> = "formData"
+  external formData: t => promise<formData> = "formData"
 
   @send
-  external json: t => Js.Promise.t<Js.Json.t> = "json"
+  external json: t => promise<JSON.t> = "json"
 
   @send
-  external text: t => Js.Promise.t<string> = "text"
+  external text: t => promise<string> = "text"
 }
 
 @val
-external fetch: string => Js.Promise.t<response> = "fetch"
+external fetch: string => promise<response> = "fetch"
 
 @val
-external fetchWithInit: (string, requestInit) => Js.Promise.t<response> = "fetch"
+external fetchWithInit: (string, requestInit) => promise<response> = "fetch"
 
 @val
-external fetchWithRequest: request => Js.Promise.t<response> = "fetch"
+external fetchWithRequest: request => promise<response> = "fetch"
 
 @val
-external fetchWithRequestInit: (request, requestInit) => Js.Promise.t<response> = "fetch"
+external fetchWithRequestInit: (request, requestInit) => promise<response> = "fetch"

package/tests/FetchTest.res

@@ -1,155 +0,0 @@
-open ReactTest
-
-let placeholderText = `{"userId":1,"id":1,"title":"delectus aut autem","completed":false}`
-let postPlaceholderText = `{"title":"foo","body":"bar","userId":1,"id":101}`
-
-module Hooks = {
-  let useFetch = () => {
-    let (state, setState) = React.useState(() => None)
-
-    React.useEffect0(() => {
-      let promise = async () => {
-        let response = await Fetch.fetch("https://jsonplaceholder.typicode.com/todos/1")
-        let body = await response->Fetch.Response.json
-
-        setState(_ => Some(body))
-      }
-
-      promise()->Promise.thenResolve(_ => ())->ignore
-
-      None
-    })
-
-    state
-  }
-
-  let useFetchWithInit = () => {
-    let (state, setState) = React.useState(() => None)
-
-    React.useEffect0(() => {
-      let promise = async () => {
-        let response = await Fetch.fetchWithInit(
-          "https://jsonplaceholder.typicode.com/todos/1",
-          Fetch.RequestInit.make(~method_=Get, ()),
-        )
-        let body = await response->Fetch.Response.json
-
-        setState(_ => Some(body))
-      }
-
-      promise()->Promise.thenResolve(_ => ())->ignore
-
-      None
-    })
-
-    state
-  }
-
-  let usePostFetchWithInit = () => {
-    let postBody = {
-      "title": "foo",
-      "body": "bar",
-      "userId": 1,
-    }
-    let (state, setState) = React.useState(() => None)
-
-    React.useEffect0(() => {
-      let promise = async () => {
-        let body = Fetch.BodyInit.make(JSON.stringifyAny(postBody)->Option.getOr(""))
-        let headers = Fetch.HeadersInit.makeWithArray([
-          ("Accept", "application/json"),
-          ("Content-Type", "application/json"),
-        ])
-        let response = await Fetch.fetchWithInit(
-          "https://jsonplaceholder.typicode.com/posts",
-          Fetch.RequestInit.make(~method_=Post, ~headers, ~body, ()),
-        )
-        let body = await response->Fetch.Response.json
-
-        setState(_ => Some(body))
-      }
-
-      promise()->Promise.thenResolve(_ => ())->ignore
-
-      None
-    })
-
-    state
-  }
-}
-
-module Home = {
-  @react.component
-  let make = (~fetchHok: unit => option<JSON.t>) => {
-    let jsonPlaceholder = fetchHok()
-
-    <div id="placeholder">
-      {React.string(jsonPlaceholder->Option.mapOr("Loading...", JSON.stringify(_)))}
-    </div>
-  }
-}
-
-@get external textContent: Dom.element => string = "textContent"
-
-testAsyncWithReact("fetch", (root, done) => {
-  let promise = async () => {
-    let _ = await act(async () => {
-      root->ReactDOM.Client.Root.render(<Home fetchHok=Hooks.useFetch />)
-    })
-
-    let _ = await screen->findByText(placeholderText)
-  }
-
-  promise()
-  ->Promise.thenResolve(_ => {
-    Assert.elementContains(
-      ~message="has result",
-      ReactDOM.querySelector("#placeholder"),
-      placeholderText,
-    )
-    done()
-  })
-  ->ignore
-})
-
-testAsyncWithReact("fetchWithInit", (root, done) => {
-  let promise = async () => {
-    let _ = await act(async () => {
-      root->ReactDOM.Client.Root.render(<Home fetchHok=Hooks.useFetchWithInit />)
-    })
-
-    let _ = await screen->findByText(placeholderText)
-  }
-
-  promise()
-  ->Promise.thenResolve(_ => {
-    Assert.elementContains(
-      ~message="has result",
-      ReactDOM.querySelector("#placeholder"),
-      placeholderText,
-    )
-    done()
-  })
-  ->ignore
-})
-
-testAsyncWithReact("postFetchWithInit", (root, done) => {
-  let promise = async () => {
-    let _ = await act(async () => {
-      root->ReactDOM.Client.Root.render(<Home fetchHok=Hooks.usePostFetchWithInit />)
-    })
-
-    let _ = await screen->findByText(postPlaceholderText)
-  }
-
-  promise()
-  ->Promise.thenResolve(_ => {
-    Assert.elementContains(
-      ~message="has result",
-      ReactDOM.querySelector("#placeholder"),
-      postPlaceholderText,
-    )
-    done()
-  })
-  ->ignore
-})

package/tests/FetchTest.res.js

@@ -1,162 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var Fetch = require("../src/Fetch.res.js");
-var React = require("react");
-var Assert = require("./utils/Assert.res.js");
-var ReactTest = require("./utils/ReactTest.res.js");
-var Caml_option = require("rescript/lib/js/caml_option.js");
-var Core__Option = require("@rescript/core/src/Core__Option.res.js");
-var JsxRuntime = require("react/jsx-runtime");
-var React$1 = require("@testing-library/react");
-
-var placeholderText = "{\"userId\":1,\"id\":1,\"title\":\"delectus aut autem\",\"completed\":false}";
-
-var postPlaceholderText = "{\"title\":\"foo\",\"body\":\"bar\",\"userId\":1,\"id\":101}";
-
-function useFetch() {
-  var match = React.useState(function () {
-        
-      });
-  var setState = match[1];
-  React.useEffect((function () {
-          var promise = async function () {
-            var response = await fetch("https://jsonplaceholder.typicode.com/todos/1");
-            var body = await response.json();
-            return setState(function (param) {
-                        return body;
-                      });
-          };
-          promise().then(function () {
-                
-              });
-        }), []);
-  return match[0];
-}
-
-function useFetchWithInit() {
-  var match = React.useState(function () {
-        
-      });
-  var setState = match[1];
-  React.useEffect((function () {
-          var promise = async function () {
-            var response = await fetch("https://jsonplaceholder.typicode.com/todos/1", Fetch.RequestInit.make("Get", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined));
-            var body = await response.json();
-            return setState(function (param) {
-                        return body;
-                      });
-          };
-          promise().then(function () {
-                
-              });
-        }), []);
-  return match[0];
-}
-
-function usePostFetchWithInit() {
-  var postBody = {
-    title: "foo",
-    body: "bar",
-    userId: 1
-  };
-  var match = React.useState(function () {
-        
-      });
-  var setState = match[1];
-  React.useEffect((function () {
-          var promise = async function () {
-            var body = Core__Option.getOr(JSON.stringify(postBody), "");
-            var headers = [
-              [
-                "Accept",
-                "application/json"
-              ],
-              [
-                "Content-Type",
-                "application/json"
-              ]
-            ];
-            var response = await fetch("https://jsonplaceholder.typicode.com/posts", Fetch.RequestInit.make("Post", Caml_option.some(headers), Caml_option.some(body), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined));
-            var body$1 = await response.json();
-            return setState(function (param) {
-                        return body$1;
-                      });
-          };
-          promise().then(function () {
-                
-              });
-        }), []);
-  return match[0];
-}
-
-var Hooks = {
-  useFetch: useFetch,
-  useFetchWithInit: useFetchWithInit,
-  usePostFetchWithInit: usePostFetchWithInit
-};
-
-function FetchTest$Home(props) {
-  var jsonPlaceholder = props.fetchHok();
-  return JsxRuntime.jsx("div", {
-              children: Core__Option.mapOr(jsonPlaceholder, "Loading...", (function (__x) {
-                      return JSON.stringify(__x);
-                    })),
-              id: "placeholder"
-            });
-}
-
-var Home = {
-  make: FetchTest$Home
-};
-
-ReactTest.testAsyncWithReact("fetch", undefined, (function (root, done) {
-        var promise = async function () {
-          await React$1.act(async function () {
-                root.render(JsxRuntime.jsx(FetchTest$Home, {
-                          fetchHok: useFetch
-                        }));
-              });
-          await React$1.screen.findByText(placeholderText);
-        };
-        promise().then(function () {
-              Assert.elementContains("has result", Caml_option.nullable_to_opt(document.querySelector("#placeholder")), placeholderText);
-              done(undefined, undefined);
-            });
-      }));
-
-ReactTest.testAsyncWithReact("fetchWithInit", undefined, (function (root, done) {
-        var promise = async function () {
-          await React$1.act(async function () {
-                root.render(JsxRuntime.jsx(FetchTest$Home, {
-                          fetchHok: useFetchWithInit
-                        }));
-              });
-          await React$1.screen.findByText(placeholderText);
-        };
-        promise().then(function () {
-              Assert.elementContains("has result", Caml_option.nullable_to_opt(document.querySelector("#placeholder")), placeholderText);
-              done(undefined, undefined);
-            });
-      }));
-
-ReactTest.testAsyncWithReact("postFetchWithInit", undefined, (function (root, done) {
-        var promise = async function () {
-          await React$1.act(async function () {
-                root.render(JsxRuntime.jsx(FetchTest$Home, {
-                          fetchHok: usePostFetchWithInit
-                        }));
-              });
-          await React$1.screen.findByText(postPlaceholderText);
-        };
-        promise().then(function () {
-              Assert.elementContains("has result", Caml_option.nullable_to_opt(document.querySelector("#placeholder")), postPlaceholderText);
-              done(undefined, undefined);
-            });
-      }));
-
-exports.placeholderText = placeholderText;
-exports.postPlaceholderText = postPlaceholderText;
-exports.Hooks = Hooks;
-exports.Home = Home;
-/*  Not a pure module */

package/tests/utils/Assert.res

@@ -1,20 +0,0 @@
-open Test
-
-@get external textContent: Dom.element => string = "textContent"
-
-let isSome = (~message: string, value: option<'a>) =>
-  switch value {
-  | Some(_) => pass(~message, ())
-  | None => fail(~message="Expected Some, got None", ())
-  }
-
-let elementContains = (~message=?, element: option<Dom.element>, substring: string) =>
-  assertion(
-    ~message?,
-    ~operator="elementContains",
-    (textContent, substring) => {
-      textContent->String.includes(substring)
-    },
-    element->Option.mapOr("Not Found", element => element->textContent),
-    substring,
-  )

package/tests/utils/Assert.res.js

@@ -1,25 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var Test = require("rescript-test/src/Test.res.js");
-var Core__Option = require("@rescript/core/src/Core__Option.res.js");
-
-function isSome(message, value) {
-  if (value !== undefined) {
-    return Test.pass(message, undefined);
-  } else {
-    return Test.fail("Expected Some, got None", undefined);
-  }
-}
-
-function elementContains(message, element, substring) {
-  Test.assertion(message, "elementContains", (function (textContent, substring) {
-          return textContent.includes(substring);
-        }), Core__Option.mapOr(element, "Not Found", (function (element) {
-              return element.textContent;
-            })), substring);
-}
-
-exports.isSome = isSome;
-exports.elementContains = elementContains;
-/* Test Not a pure module */

package/tests/utils/ReactTest.res

@@ -1,47 +0,0 @@
-open Test
-open Webapi.Dom
-
-@send external remove: Dom.element => unit = "remove"
-
-let createContainer = () => {
-  let containerElement = Webapi.Dom.document->Document.createElement("div")
-  let _ = containerElement->Element.setAttribute("id", "test")
-
-  let _ =
-    Webapi.Dom.document
-    ->Document.asHtmlDocument
-    ->Option.map(htmlDocument =>
-      htmlDocument
-      ->HtmlDocument.body
-      ->Option.forEach(body => body->Element.appendChild(~child=containerElement))
-    )
-
-  ReactDOM.Client.createRoot(containerElement)
-}
-
-let cleanupContainer = container => {
-  let containerElement = ReactDOM.querySelector("#test")
-  switch containerElement {
-  | Some(element) => element->remove
-  | None => ()
-  }
-  container->ReactDOM.Client.Root.unmount()
-}
-
-let testWithReact = testWith(~setup=createContainer, ~teardown=cleanupContainer, ...)
-
-let testAsyncWithReact = testAsyncWith(~setup=createContainer, ~teardown=cleanupContainer, ...)
-
-// @testing-library/react
-@module("@testing-library/react") external act: (unit => Promise.t<unit>) => Promise.t<unit> = "act"
-
-@module("@@testing-library/react")
-external waitFor: (unit => Promise.t<'a>) => Promise.t<'a> = "waitFor"
-
-type screen
-
-@module("@testing-library/react") @val
-external screen: screen = "screen"
-
-@send
-external findByText: (screen, string) => Promise.t<Dom.element> = "findByText"

package/tests/utils/ReactTest.res.js

@@ -1,41 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var Test = require("rescript-test/src/Test.res.js");
-var Caml_option = require("rescript/lib/js/caml_option.js");
-var Core__Option = require("@rescript/core/src/Core__Option.res.js");
-var Client = require("react-dom/client");
-var Webapi__Dom__Document = require("rescript-webapi/src/Webapi/Dom/Webapi__Dom__Document.res.js");
-
-function createContainer() {
-  var containerElement = document.createElement("div");
-  containerElement.setAttribute("id", "test");
-  Core__Option.map(Webapi__Dom__Document.asHtmlDocument(document), (function (htmlDocument) {
-          Core__Option.forEach(Caml_option.nullable_to_opt(htmlDocument.body), (function (body) {
-                  body.appendChild(containerElement);
-                }));
-        }));
-  return Client.createRoot(containerElement);
-}
-
-function cleanupContainer(container) {
-  var containerElement = document.querySelector("#test");
-  if (!(containerElement == null)) {
-    containerElement.remove();
-  }
-  container.unmount();
-}
-
-function testWithReact(extra, extra$1) {
-  return Test.testWith(createContainer, cleanupContainer, extra, extra$1);
-}
-
-function testAsyncWithReact(extra, extra$1, extra$2) {
-  return Test.testAsyncWith(createContainer, cleanupContainer, extra, extra$1, extra$2);
-}
-
-exports.createContainer = createContainer;
-exports.cleanupContainer = cleanupContainer;
-exports.testWithReact = testWithReact;
-exports.testAsyncWithReact = testAsyncWithReact;
-/* Test Not a pure module */