@defjs/core 0.0.0-test-002 → 0.0.0-test-004

package/index.js

@@ -1,48 +1,93 @@
-// src/error.ts
-var ERR_ABORTED = new Error("ERR_ABORTED");
-var ERR_TIMEOUT = new Error("ERR_TIMEOUT");
-var ERR_NETWORK = new Error("ERR_NETWORK");
-var ERR_NOT_FOUND_HANDLER = new Error("ERR_NOT_FOUND_HANDLER");
-var ERR_OBSERVE = new Error("ERR_OBSERVE");
-var ERR_NOT_SET_ALIAS = new Error("ERR_NOT_SET_ALIAS");
-var ERR_UNSUPPORTED_FIELD_TYPE = new Error("ERR_UNSUPPORTED_FIELD_TYPE");
-var ERR_INVALID_CLIENT = new Error("ERR_INVALID_CLIENT");
-var ERR_NOT_FOUND_GLOBAL_CLIENT = new Error("ERR_NOT_FOUND_GLOBAL_CLIENT");
-var ERR_INVALID_HTTP_CONTEXT_TOKEN = new Error("ERR_INVALID_HTTP_CONTEXT_TOKEN");
-var ERR_UNKNOWN = new Error("ERR_UNKNOWN");
-
+const ERR_ABORTED = new Error("ERR_ABORTED");
+const ERR_TIMEOUT = new Error("ERR_TIMEOUT");
+const ERR_NETWORK = new Error("ERR_NETWORK");
+const ERR_NOT_FOUND_HANDLER = new Error("ERR_NOT_FOUND_HANDLER");
+const ERR_OBSERVE = new Error("ERR_OBSERVE");
+const ERR_NOT_SET_ALIAS = new Error("ERR_NOT_SET_ALIAS");
+const ERR_UNSUPPORTED_FIELD_TYPE = new Error("ERR_UNSUPPORTED_FIELD_TYPE");
+const ERR_INVALID_CLIENT = new Error("ERR_INVALID_CLIENT");
+const ERR_NOT_FOUND_GLOBAL_CLIENT = new Error("ERR_NOT_FOUND_GLOBAL_CLIENT");
+const ERR_INVALID_HTTP_CONTEXT_TOKEN = new Error("ERR_INVALID_HTTP_CONTEXT_TOKEN");
+const ERR_UNKNOWN = new Error("ERR_UNKNOWN");
 class HttpErrorResponse extends Error {
   status;
   statusText;
   url;
   headers;
-  ok;
   body;
   constructor(init) {
-    const status = init.status ?? 0;
-    const statusText = init.statusText ?? "";
+    const status = init?.status ?? 0;
+    const statusText = init?.statusText ?? "";
     const ok = status >= 200 && status < 300;
-    const headers = init.headers ?? new Headers;
-    const url = init.url ?? null;
-    const body = init.body ?? null;
+    const headers = init?.headers ?? new Headers();
+    const url = init?.url ?? "";
+    const body = init?.body ?? null;
     let message;
     if (ok) {
-      message = `Http failure during parsing for ${init.url || "(unknown url)"}`;
+      message = `Http failure during parsing for ${url}`;
     } else {
-      message = `Http failure response for ${init.url || "(unknown url)"}: ${init.status} ${init.statusText}`;
+      message = `Http failure response for ${url || "(unknown url)"}: ${status}`;
+      if (statusText) {
+        message += ` - ${statusText}`;
+      }
     }
-    super(message, { cause: init.error });
+    super(message, { cause: init?.error });
     super.name = "HttpErrorResponse";
     this.statusText = statusText;
     this.url = url;
     this.headers = headers;
     this.status = status;
-    this.ok = ok;
     this.body = body;
   }
 }
 
-// src/context.ts
+function __getContentLength(headers) {
+  const value = headers.get("Content-Length");
+  if (!value) {
+    return 0;
+  }
+  const num = Number(value);
+  if (isNaN(num)) {
+    return 0;
+  }
+  return num;
+}
+function __getContentType(headers) {
+  return headers.get("Content-Type") || "";
+}
+function __parseBody(params) {
+  const { request, content, contentType } = params;
+  const responseType = request.responseType;
+  switch (responseType) {
+    case "json": {
+      const text = new TextDecoder().decode(content);
+      if (text === "") {
+        return null;
+      }
+      return JSON.parse(text);
+    }
+    case "text":
+      return new TextDecoder().decode(content);
+    case "blob": {
+      return new Blob([content], { type: contentType });
+    }
+    case "arraybuffer":
+      return content.buffer;
+    default:
+      return null;
+  }
+}
+function __concatChunks(chunks, totalLength) {
+  const chunksAll = new Uint8Array(totalLength);
+  let position = 0;
+  for (const chunk of chunks) {
+    chunksAll.set(chunk, position);
+    position += chunk.length;
+  }
+  return chunksAll;
+}
+
+const HTTP_CONTEXT_TOKEN = Symbol("HttpContextToken");
 function makeHttpContextToken(defaultValue) {
   Object.defineProperty(defaultValue, HTTP_CONTEXT_TOKEN, { value: defaultValue });
   return defaultValue;
@@ -50,8 +95,28 @@ function makeHttpContextToken(defaultValue) {
 function isHttpContextToken(value) {
   return typeof value === "function" && HTTP_CONTEXT_TOKEN in value;
 }
-function makeHttpContext() {
-  const ctx = new Map;
+const HTTP_CONTEXT = Symbol("HttpContext");
+function isHttpContext(value) {
+  return typeof value === "object" && value !== null && HTTP_CONTEXT in value;
+}
+function makeHttpContext(entries) {
+  const ctx = /* @__PURE__ */ new Map();
+  switch (true) {
+    case Array.isArray(entries): {
+      for (const [token, value] of entries) {
+        if (isHttpContextToken(token)) {
+          ctx.set(token, value);
+        }
+      }
+      break;
+    }
+    case isHttpContext(entries): {
+      for (const [token, value] of entries[HTTP_CONTEXT]) {
+        ctx.set(token, value);
+      }
+      break;
+    }
+  }
   return {
     set(token, value) {
       if (!isHttpContextToken(token)) {
@@ -78,15 +143,30 @@ function makeHttpContext() {
     },
     keys() {
       return ctx.keys();
-    }
+    },
+    get length() {
+      return Array.from(ctx.keys()).length;
+    },
+    [HTTP_CONTEXT]: ctx
   };
 }
-var HTTP_CONTEXT_TOKEN = Symbol("HttpContextToken");
 
-// src/field.ts
+const FIELD = Symbol("field");
+var FieldType = /* @__PURE__ */ ((FieldType2) => {
+  FieldType2[FieldType2["Json"] = 0] = "Json";
+  FieldType2[FieldType2["Query"] = 1] = "Query";
+  FieldType2[FieldType2["Param"] = 2] = "Param";
+  FieldType2[FieldType2["Header"] = 3] = "Header";
+  FieldType2[FieldType2["Form"] = 4] = "Form";
+  FieldType2[FieldType2["Body"] = 5] = "Body";
+  FieldType2[FieldType2["UrlForm"] = 6] = "UrlForm";
+  return FieldType2;
+})(FieldType || {});
 function field(defaultValue) {
   const meta = {
-    alias: new Map,
+    // todo
+    required: typeof defaultValue !== "undefined",
+    alias: /* @__PURE__ */ new Map(),
     validators: [],
     asyncValidator: []
   };
@@ -95,31 +175,31 @@ function field(defaultValue) {
     value: meta
   });
   getter.withJson = (alias) => {
-    meta.alias.set(1 /* Json */, alias);
+    meta.alias.set(0 /* Json */, alias);
     return getter;
   };
   getter.withForm = (alias) => {
-    meta.alias.set(5 /* Form */, alias);
+    meta.alias.set(4 /* Form */, alias);
     return getter;
   };
   getter.withQuery = (alias) => {
-    meta.alias.set(2 /* Query */, alias);
+    meta.alias.set(1 /* Query */, alias);
     return getter;
   };
   getter.withParam = (alias) => {
-    meta.alias.set(3 /* Param */, alias);
+    meta.alias.set(2 /* Param */, alias);
     return getter;
   };
   getter.withHeader = (alias) => {
-    meta.alias.set(4 /* Header */, alias);
+    meta.alias.set(3 /* Header */, alias);
     return getter;
   };
   getter.withUrlForm = (alias) => {
-    meta.alias.set(7 /* UrlForm */, alias);
+    meta.alias.set(6 /* UrlForm */, alias);
     return getter;
   };
   getter.withBody = () => {
-    meta.alias.set(6 /* Body */, undefined);
+    meta.alias.set(5 /* Body */, void 0);
     return getter;
   };
   getter.withValidators = (...fn) => {
@@ -135,21 +215,8 @@ function field(defaultValue) {
 function __getFieldMetadata(field2) {
   return field2[FIELD];
 }
-function validatorField(validators, value) {
-  for (const fn of validators) {
-    const err = fn(value);
-    if (err) {
-      throw err;
-    }
-  }
-}
-async function asyncValidatorField(asyncValidator, value) {
-  for (const fn of asyncValidator) {
-    const err = await fn(value);
-    if (err) {
-      throw err;
-    }
-  }
+async function doValid(validators, value) {
+  await Promise.all(validators.map((validator) => validator(value)));
 }
 function isField(value) {
   return !!value && typeof value === "function" && FIELD in value;
@@ -157,26 +224,25 @@ function isField(value) {
 function isFieldGroup(value) {
   return !!value && typeof value === "object" && Object.entries(value).every(([, v]) => isField(v));
 }
-var FIELD = Symbol("field");
 
-// src/handler/handler.ts
-var globalHttpHandler = undefined;
-var getGlobalHttpHandler = () => globalHttpHandler;
+let globalHttpHandler = void 0;
+const getGlobalHttpHandler = () => globalHttpHandler;
 
-// src/interceptor/interceptor.ts
 function makeInterceptorChain(interceptors) {
-  return interceptors.reduceRight((fn, interceptor) => {
-    return (initReq, finalHandlerFn) => interceptor(initReq, (req) => fn(req, finalHandlerFn));
-  }, (req, fn) => fn(req));
+  return interceptors.reduceRight(
+    (fn, interceptor) => {
+      return (initReq, finalHandlerFn) => interceptor(initReq, (req) => fn(req, finalHandlerFn));
+    },
+    (req, fn) => fn(req)
+  );
 }
 
-// src/response.ts
 function __makeResponse(options) {
-  const status = options.status ?? 0;
-  const statusText = options.statusText ?? "";
-  const url = options.url ?? "";
-  const headers = options.headers ?? new Headers;
-  const body = options.body ?? null;
+  const status = options?.status ?? 0;
+  const statusText = options?.statusText ?? "";
+  const url = options?.url ?? "";
+  const headers = options?.headers ?? new Headers();
+  const body = options?.body ?? null;
   return {
     status,
     statusText,
@@ -186,7 +252,6 @@ function __makeResponse(options) {
   };
 }
 
-// src/request.ts
 function __serializeBody(body) {
   switch (true) {
     case body instanceof FormData:
@@ -232,19 +297,19 @@ function __buildFieldDefaultValue(input) {
   }
   if (isFieldGroup(input)) {
     const obj = {};
-    for (const [key, field3] of Object.entries(input)) {
-      obj[key] = field3();
+    for (const [key, field] of Object.entries(input)) {
+      obj[key] = field();
     }
     return obj;
   }
-  return;
+  return void 0;
 }
 function defineRequest(method, endpoint) {
   let requiredInput = false;
-  let field3;
+  let field;
   let interceptors = [];
   let responseType = "json";
-  let context2;
+  let context;
   let observe = "body";
   let withCredentials = false;
   let validators = [];
@@ -253,7 +318,7 @@ function defineRequest(method, endpoint) {
     let uploadProgress;
     let downloadProgress;
     let abortSignal;
-    const getInitValue = () => __buildFieldDefaultValue(field3);
+    const getInitValue = () => __buildFieldDefaultValue(field);
     const setUploadProgress = (fn2) => {
       uploadProgress = fn2;
     };
@@ -288,41 +353,41 @@ function defineRequest(method, endpoint) {
       } else if (timeout > 0) {
         abortSignal = AbortSignal.timeout(timeout);
       }
-      const client2 = isClient(doRequestOptions?.client) ? doRequestOptions.client : getGlobalClient();
-      const clientOptions = getClientConfig(client2);
+      const client = isClient(doRequestOptions?.client) ? doRequestOptions.client : getGlobalClient();
+      const clientOptions = getClientConfig(client);
       const req = {
         host: clientOptions?.host,
         method,
         endpoint,
-        queryParams: new URLSearchParams,
-        headers: new Headers,
-        body: undefined,
+        queryParams: new URLSearchParams(),
+        headers: new Headers(),
+        body: void 0,
         withCredentials,
         responseType,
-        context: context2 || makeHttpContext(),
+        context: context || makeHttpContext(),
         observe,
         uploadProgress,
         downloadProgress,
         timeout,
         abort: abortSignal
       };
-      const handler2 = doRequestOptions?.handler || clientOptions?.handler || getGlobalHttpHandler();
-      if (!handler2) {
+      const handler = doRequestOptions?.handler || clientOptions?.handler || getGlobalHttpHandler();
+      if (!handler) {
         throw ERR_NOT_FOUND_HANDLER;
       }
-      if (requiredInput) {
-        await __fillRequestFromField(req, field3, input);
+      if (requiredInput && field) {
+        await __fillRequestFromField(req, field, input);
       }
       const chain = makeInterceptorChain([...interceptors]);
-      let res = await chain(req, handler2);
+      let res = await chain(req, handler);
       if (typeof transformResponse === "function") {
         try {
           res = __makeResponse({
             ...res,
             body: transformResponse(res)
           });
-        } catch (error3) {
-          throw new HttpErrorResponse({ error: error3 });
+        } catch (error) {
+          throw new HttpErrorResponse({ error });
         }
       }
       switch (req.observe) {
@@ -342,7 +407,7 @@ function defineRequest(method, endpoint) {
     };
   };
   fn.withField = (value) => {
-    field3 = value;
+    field = value;
     requiredInput = true;
     return fn;
   };
@@ -351,7 +416,7 @@ function defineRequest(method, endpoint) {
     return fn;
   };
   fn.withContext = (value) => {
-    context2 = value;
+    context = value;
     return fn;
   };
   fn.withCredentials = (value) => {
@@ -360,7 +425,6 @@ function defineRequest(method, endpoint) {
   };
   fn.withValidators = (value) => {
     validators = value;
-    console.log(validators);
     return fn;
   };
   fn.withTransformResponse = (value) => {
@@ -383,15 +447,6 @@ function __fillUrl(endpoint, params) {
   });
 }
 async function __fillRequestFromField(request, fieldOrFieldGroup, input) {
-  async function doValid(validators, value) {
-    for (const validator of validators) {
-      const err = await validator(value);
-      if (err) {
-        return err;
-      }
-    }
-    return;
-  }
   function inputIsObject(input2) {
     return typeof input2 === "object" && input2 !== null;
   }
@@ -428,57 +483,64 @@ async function __fillRequestFromField(request, fieldOrFieldGroup, input) {
     sp.set(key, serializeToString(value));
     return sp;
   }
+  function getValidValue(value, defaultValue) {
+    switch (true) {
+      case typeof value === "undefined":
+        return defaultValue;
+      case (typeof value === "object" && value === null):
+        return value;
+      default:
+        return value;
+    }
+  }
   if (isField(fieldOrFieldGroup)) {
     let params;
     let queryParams;
     let headers;
-    let body = undefined;
-    const fieldValue = input ?? fieldOrFieldGroup();
+    let body = void 0;
+    const validValue = getValidValue(input, fieldOrFieldGroup());
     const meta = __getFieldMetadata(fieldOrFieldGroup);
-    const err = await doValid([...meta.validators, ...meta.asyncValidator], fieldValue);
-    if (err) {
-      throw err;
-    }
+    await doValid([...meta.validators, ...meta.asyncValidator], validValue);
     for (const [type, aliasName] of meta.alias) {
       switch (type) {
-        case 2 /* Query */: {
+        case FieldType.Query: {
           if (!aliasName) {
             throw ERR_NOT_SET_ALIAS;
           }
-          queryParams = appendValue(new URLSearchParams, aliasName, fieldValue);
+          queryParams = appendValue(new URLSearchParams(), aliasName, validValue);
           break;
         }
-        case 3 /* Param */: {
+        case FieldType.Param: {
           if (!aliasName) {
             throw ERR_NOT_SET_ALIAS;
           }
-          params = setValue(new Map, aliasName, fieldValue);
+          params = setValue(/* @__PURE__ */ new Map(), aliasName, validValue);
           break;
         }
-        case 4 /* Header */: {
+        case FieldType.Header: {
           if (!aliasName) {
             throw ERR_NOT_SET_ALIAS;
           }
-          headers = appendValue(new Headers, aliasName, fieldValue);
+          headers = appendValue(new Headers(), aliasName, validValue);
           break;
         }
-        case 5 /* Form */: {
+        case FieldType.Form: {
           if (!aliasName) {
             throw ERR_NOT_SET_ALIAS;
           }
-          body = appendValue(new FormData, aliasName, fieldValue);
+          body = appendValue(new FormData(), aliasName, validValue);
           break;
         }
-        case 7 /* UrlForm */: {
+        case FieldType.UrlForm: {
           if (!aliasName) {
             throw ERR_NOT_SET_ALIAS;
           }
-          body = appendValue(new URLSearchParams, aliasName, fieldValue);
+          body = appendValue(new URLSearchParams(), aliasName, validValue);
           break;
         }
-        case 1 /* Json */:
-        case 6 /* Body */:
-          body = fieldValue;
+        case FieldType.Json:
+        case FieldType.Body:
+          body = validValue;
           break;
       }
     }
@@ -491,55 +553,52 @@ async function __fillRequestFromField(request, fieldOrFieldGroup, input) {
     return;
   }
   if (isFieldGroup(fieldOrFieldGroup) && inputIsObject(input)) {
-    let params = new Map;
-    let queryParams = new URLSearchParams;
-    let headers = new Headers;
-    let urlForm = new URLSearchParams;
-    let formData = new FormData;
+    let params = /* @__PURE__ */ new Map();
+    let queryParams = new URLSearchParams();
+    let headers = new Headers();
+    let urlForm = new URLSearchParams();
+    let formData = new FormData();
     const json = {};
-    let body = undefined;
+    let body = void 0;
     let lastBodyField;
-    for (const [propertyKey, field3] of Object.entries(fieldOrFieldGroup)) {
-      const meta = __getFieldMetadata(field3);
+    for (const [propertyKey, field] of Object.entries(fieldOrFieldGroup)) {
+      const meta = __getFieldMetadata(field);
       for (const [type, aliasName] of meta.alias) {
         const valueKey = aliasName || propertyKey;
-        const value = input[propertyKey] || field3();
-        const err = await doValid([...meta.validators, ...meta.asyncValidator], value);
-        if (err) {
-          throw err;
-        }
+        const value = getValidValue(input[propertyKey], field());
+        await doValid([...meta.validators, ...meta.asyncValidator], value);
         switch (type) {
-          case 1 /* Json */: {
+          case FieldType.Json: {
             Object.defineProperty(json, valueKey, {
               value,
               writable: true,
               enumerable: true
             });
-            lastBodyField = 1 /* Json */;
+            lastBodyField = FieldType.Json;
             break;
           }
-          case 2 /* Query */:
+          case FieldType.Query:
             queryParams = appendValue(queryParams, valueKey, value);
             break;
-          case 3 /* Param */:
+          case FieldType.Param:
             params = setValue(params, valueKey, value);
             break;
-          case 4 /* Header */:
+          case FieldType.Header:
             headers = appendValue(headers, valueKey, value);
             break;
-          case 5 /* Form */: {
+          case FieldType.Form: {
             formData = appendValue(formData, valueKey, value);
-            lastBodyField = 5 /* Form */;
+            lastBodyField = FieldType.Form;
             break;
           }
-          case 7 /* UrlForm */: {
+          case FieldType.UrlForm: {
             urlForm = appendValue(urlForm, valueKey, value);
-            lastBodyField = 7 /* UrlForm */;
+            lastBodyField = FieldType.UrlForm;
             break;
           }
-          case 6 /* Body */: {
+          case FieldType.Body: {
             body = value;
-            lastBodyField = 6 /* Body */;
+            lastBodyField = FieldType.Body;
             break;
           }
         }
@@ -549,16 +608,16 @@ async function __fillRequestFromField(request, fieldOrFieldGroup, input) {
     request.queryParams = queryParams;
     request.headers = headers;
     switch (lastBodyField) {
-      case 6 /* Body */:
+      case FieldType.Body:
         request.body = body;
         break;
-      case 5 /* Form */:
+      case FieldType.Form:
         request.body = formData;
         break;
-      case 7 /* UrlForm */:
+      case FieldType.UrlForm:
         request.body = urlForm;
         break;
-      case 1 /* Json */:
+      case FieldType.Json:
         request.body = json;
         break;
     }
@@ -567,66 +626,14 @@ async function __fillRequestFromField(request, fieldOrFieldGroup, input) {
   throw ERR_UNSUPPORTED_FIELD_TYPE;
 }
 
-// src/handler/util.ts
-function __getContentLength(headers) {
-  const value = headers.get("Content-Length");
-  if (!value) {
-    return 0;
+function __createRequest(request) {
+  const url = new URL(request.endpoint, request.host);
+  if (request.queryParams) {
+    url.search = request.queryParams.toString();
   }
-  const num = Number(value);
-  if (isNaN(num)) {
-    return 0;
-  }
-  return num;
-}
-function __getContentType(headers) {
-  return headers.get("Content-Type") || "";
-}
-function __parseBody(params) {
-  const { request, content, contentType } = params;
-  const responseType = request.responseType;
-  if (!responseType) {
-    return null;
-  }
-  switch (responseType) {
-    case "json": {
-      const text = new TextDecoder().decode(content);
-      if (text === "") {
-        return null;
-      }
-      console.log(text);
-      return JSON.parse(text);
-    }
-    case "text":
-      return new TextDecoder().decode(content);
-    case "blob": {
-      return new Blob([content], { type: contentType });
-    }
-    case "arraybuffer":
-      return content.buffer;
-    default:
-      return null;
-  }
-}
-function __concatChunks(chunks, totalLength) {
-  const chunksAll = new Uint8Array(totalLength);
-  let position = 0;
-  for (const chunk of chunks) {
-    chunksAll.set(chunk, position);
-    position += chunk.length;
-  }
-  return chunksAll;
-}
-
-// src/handler/fetch/fetch.ts
-function __createRequest(request2) {
-  const url = new URL(request2.endpoint, request2.host);
-  if (request2.queryParams) {
-    url.search = request2.queryParams.toString();
-  }
-  const headers = request2.headers ?? new Headers;
+  const headers = request.headers ?? new Headers();
   if (!headers.has("Content-Type")) {
-    const detectedType = __detectContentTypeHeader(request2.body);
+    const detectedType = __detectContentTypeHeader(request.body);
     if (detectedType) {
       headers.set("Content-Type", detectedType);
     }
@@ -634,41 +641,40 @@ function __createRequest(request2) {
   if (!headers.has("Accept")) {
     headers.set("Accept", "application/json, text/plain, */*");
   }
-  const credentials = request2.withCredentials ? "include" : undefined;
-  const fetchConfig = request2.context?.get(FETCH_CONFIG_KEY) || {};
+  const credentials = request.withCredentials ? "include" : void 0;
   return new Request(url, {
-    ...fetchConfig,
     headers,
-    method: request2.method,
-    body: __serializeBody(request2.body),
-    signal: request2.abort,
+    method: request.method,
+    body: __serializeBody(request.body),
+    signal: request.abort,
     credentials
   });
 }
 async function fetchHandler(httpRequest) {
   const downloadProgress = httpRequest.downloadProgress;
-  const request2 = __createRequest(httpRequest);
-  let response3;
+  const request = __createRequest(httpRequest);
+  const abortSignal = httpRequest.abort;
+  let response;
   try {
-    response3 = await (globalThis || window).fetch(request2);
-  } catch (error4) {
-    if (error4 instanceof DOMException) {
+    response = await globalThis.fetch(request);
+  } catch (error) {
+    if (abortSignal?.aborted && abortSignal.reason instanceof Error) {
       switch (true) {
-        case (error4.name === "AbortError" || error4.code === error4.ABORT_ERR):
+        case abortSignal.reason.name === "AbortError":
           throw new HttpErrorResponse({ error: ERR_ABORTED });
-        case (error4.name === "TimeoutError" || error4.code === error4.TIMEOUT_ERR):
+        case abortSignal.reason.name === "TimeoutError":
           throw new HttpErrorResponse({ error: ERR_TIMEOUT });
       }
     }
-    throw new HttpErrorResponse({ error: error4 });
+    throw new HttpErrorResponse({ error });
   }
-  const { ok, headers, status, statusText, url } = response3;
+  const { ok, headers, status, statusText, url } = response;
   const contentLength = __getContentLength(headers);
   const contentType = __getContentType(headers);
   let body = null;
-  if (response3.body) {
+  if (response.body) {
     const chunks = [];
-    const reader = response3.body.getReader();
+    const reader = response.body.getReader();
     let receivedLength = 0;
     while (true) {
       const { done, value } = await reader.read();
@@ -690,9 +696,9 @@ async function fetchHandler(httpRequest) {
         content: chunksAll,
         contentType
       });
-    } catch (error4) {
+    } catch (error) {
       throw new HttpErrorResponse({
-        error: error4,
+        error,
         status,
         statusText,
         headers,
@@ -717,20 +723,22 @@ async function fetchHandler(httpRequest) {
     body
   });
 }
-var FETCH_CONFIG_KEY = makeHttpContextToken(() => ({}));
-// src/client.ts
+
+const CLIENT = Symbol("Client");
+let globalClient;
 function isClient(value) {
   return typeof value === "object" && value !== null && CLIENT in value;
 }
-function getClientConfig(client2) {
-  if (!isClient(client2)) {
+function getClientConfig(client) {
+  if (!isClient(client)) {
     throw ERR_INVALID_CLIENT;
   }
-  return client2[CLIENT];
+  return client[CLIENT];
 }
 function createClient(options) {
   const conf = {
     host: options.host,
+    strict: options.strict ?? true,
     interceptors: options.interceptors ?? [],
     handler: options.handler || fetchHandler
   };
@@ -738,8 +746,8 @@ function createClient(options) {
     [CLIENT]: conf
   };
 }
-function cloneClient(client2, options) {
-  const preConf = getClientConfig(client2);
+function cloneClient(client, options) {
+  const preConf = getClientConfig(client);
   const conf = {
     ...preConf,
     ...options
@@ -754,70 +762,68 @@ function getGlobalClient() {
   }
   return globalClient;
 }
-function setGlobalClient(client2) {
-  globalClient = client2;
+function setGlobalClient(client) {
+  globalClient = client;
 }
 function restGlobalClient() {
-  globalClient = undefined;
+  globalClient = void 0;
 }
 function createGlobalClient(options) {
   globalClient = createClient(options);
 }
-var CLIENT = Symbol("Client");
-var globalClient;
-// src/interceptor/authorization/basic_auth_interceptor.ts
+
 function basicAuthInterceptor(fn, options) {
   let encode = options?.encode;
   if (!encode) {
-    const btoa = (globalThis || window).btoa;
+    const btoa = globalThis.btoa;
     if (typeof btoa !== "function") {
       throw new Error("BasicAuthInterceptor is not supported in this environment");
     }
     encode = (data) => btoa(`${data.username}:${data.password}`);
   }
   return (req, next) => {
-    const headers = req.headers || new Headers;
+    const headers = req.headers || new Headers();
     headers.set("Authorization", `Basic ${encode(fn())}`);
     req.headers = headers;
     return next(req);
   };
 }
-// src/validator.ts
-var required = (value) => {
+
+const required = (value) => {
   if (!value) {
     return new Error("required");
   }
   return null;
 };
-var requiredTrue = (value) => {
+const requiredTrue = (value) => {
   if (typeof value !== "boolean" || !value) {
     return new Error("requiredTrue");
   }
   return null;
 };
-var minLength = (min) => {
+const minLength = (min2) => {
   return (value) => {
     if (typeof value !== "string") {
       return new Error("invalid string");
     }
-    if (value.length < min) {
-      return new Error(`minLength ${min}`);
+    if (value.length < min2) {
+      return new Error(`minLength ${min2}`);
     }
     return null;
   };
 };
-var maxLength = (max) => {
+const maxLength = (max2) => {
   return (value) => {
     if (typeof value !== "string") {
       return new Error("invalid string");
     }
-    if (value.length > max) {
-      return new Error(`maxLength ${max}`);
+    if (value.length > max2) {
+      return new Error(`maxLength ${max2}`);
     }
     return null;
   };
 };
-var min = (min2) => {
+const min = (min2) => {
   return (value) => {
     if (typeof value !== "number" || isNaN(value)) {
       return new Error("invalid number");
@@ -828,7 +834,7 @@ var min = (min2) => {
     return null;
   };
 };
-var max = (max2) => {
+const max = (max2) => {
   return (value) => {
     if (typeof value !== "number" || isNaN(value)) {
       return new Error("invalid number");
@@ -839,7 +845,7 @@ var max = (max2) => {
     return null;
   };
 };
-var pattern = (pattern2) => {
+const pattern = (pattern2) => {
   return (value) => {
     if (typeof value !== "string") {
       return new Error("invalid string");
@@ -850,43 +856,5 @@ var pattern = (pattern2) => {
     return null;
   };
 };
-export {
-  validatorField,
-  setGlobalClient,
-  restGlobalClient,
-  requiredTrue,
-  required,
-  pattern,
-  minLength,
-  min,
-  maxLength,
-  max,
-  makeHttpContextToken,
-  makeHttpContext,
-  isHttpContextToken,
-  isFieldGroup,
-  isField,
-  isClient,
-  getGlobalClient,
-  field,
-  fetchHandler,
-  defineRequest,
-  createGlobalClient,
-  createClient,
-  cloneClient,
-  basicAuthInterceptor,
-  asyncValidatorField,
-  HttpErrorResponse,
-  FETCH_CONFIG_KEY,
-  ERR_UNSUPPORTED_FIELD_TYPE,
-  ERR_UNKNOWN,
-  ERR_TIMEOUT,
-  ERR_OBSERVE,
-  ERR_NOT_SET_ALIAS,
-  ERR_NOT_FOUND_HANDLER,
-  ERR_NOT_FOUND_GLOBAL_CLIENT,
-  ERR_NETWORK,
-  ERR_INVALID_HTTP_CONTEXT_TOKEN,
-  ERR_INVALID_CLIENT,
-  ERR_ABORTED
-};
+
+export { ERR_ABORTED, ERR_INVALID_CLIENT, ERR_INVALID_HTTP_CONTEXT_TOKEN, ERR_NETWORK, ERR_NOT_FOUND_GLOBAL_CLIENT, ERR_NOT_FOUND_HANDLER, ERR_NOT_SET_ALIAS, ERR_OBSERVE, ERR_TIMEOUT, ERR_UNKNOWN, ERR_UNSUPPORTED_FIELD_TYPE, HttpErrorResponse, basicAuthInterceptor, cloneClient, createClient, createGlobalClient, defineRequest, doValid, fetchHandler, field, getGlobalClient, isClient, isField, isFieldGroup, isHttpContextToken, makeHttpContext, makeHttpContextToken, max, maxLength, min, minLength, pattern, required, requiredTrue, restGlobalClient, setGlobalClient };