@defjs/core 0.0.0-test-0014 → 0.0.0-test-000

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 MunMunMiao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/{dist/index.d.ts → index.d.ts}

@@ -1,15 +1,26 @@
-export type HttpContextToken<T> = () => T;
+declare const HTTP_CONTEXT_TOKEN: unique symbol;
+export type HttpContextToken<T> = (() => T) & {
+	readonly [HTTP_CONTEXT_TOKEN]: () => T;
+};
 export declare function makeHttpContextToken<T>(defaultValue: () => T): HttpContextToken<T>;
+export declare function isHttpContextToken(value: unknown): value is HttpContextToken<unknown>;
 export type HttpContext = {
 	set<T>(token: HttpContextToken<T>, value: T): HttpContext;
 	get<T>(token: HttpContextToken<T>): T;
-	delete(token: HttpContextToken<unknown>): HttpContext;
+	del(token: HttpContextToken<unknown>): HttpContext;
 	has(token: HttpContextToken<unknown>): boolean;
 	keys(): IterableIterator<HttpContextToken<unknown>>;
 };
 export declare function makeHttpContext(): HttpContext;
 export type ValidatorFn<T = unknown> = (value: T) => Error | null | undefined;
 export type AsyncValidatorFn<T = unknown> = (value: T) => Promise<Error | null | undefined>;
+export declare const required: ValidatorFn;
+export declare const requiredTrue: ValidatorFn;
+export declare const minLength: (min: number) => ValidatorFn;
+export declare const maxLength: (max: number) => ValidatorFn;
+export declare const min: (min: number) => ValidatorFn;
+export declare const max: (max: number) => ValidatorFn;
+export declare const pattern: (pattern: string | RegExp) => ValidatorFn;
 declare const FIELD: unique symbol;
 declare enum FieldType {
 	Json = 1,
@@ -38,25 +49,31 @@ export type Field<T = undefined> = (() => T) & {
 export declare function field(): Field;
 export declare function field<T>(): Field<T | undefined>;
 export declare function field<T>(defaultValue: T): Field<T>;
+export declare function validatorField(validators: ValidatorFn<any>[], value: unknown): void;
+export declare function asyncValidatorField(asyncValidator: AsyncValidatorFn<any>[], value: unknown): Promise<void>;
 export declare function isField(value: unknown): value is Field;
 export declare function isFieldGroup(value: unknown): value is Record<PropertyKey, Field>;
+declare const HTTP_RESPONSE: unique symbol;
 export type HttpResponseBody = string | ArrayBuffer | Blob | object | null;
-export type HttpResponse<R> = {
-	ok: true;
-	status: number;
-	statusText: string;
-	url: string;
-	headers: Headers;
-	body: R | null;
+export type HttpResponse<R> = ({
+	readonly ok: true;
+	readonly status: number;
+	readonly statusText: string;
+	readonly url: string;
+	readonly headers: Headers;
+	readonly body: R | null;
 } | {
-	ok: false;
-	error: Error;
-	status: number;
-	statusText: string;
-	url: string;
-	headers: Headers;
-	body: R | null;
+	readonly ok: false;
+	readonly error: Error;
+	readonly status: number;
+	readonly statusText: string;
+	readonly url: string;
+	readonly headers: Headers;
+	readonly body: null;
+}) & {
+	readonly [HTTP_RESPONSE]: unknown;
 };
+export declare function isHttpResponse<R>(value: unknown): value is HttpResponse<R>;
 export type MakeResponseOptions<R> = {
 	status?: number;
 	statusText?: string;
@@ -67,6 +84,14 @@ export type MakeResponseOptions<R> = {
 };
 export declare function makeResponse<R>(options: MakeResponseOptions<R>): HttpResponse<R>;
 export type InterceptorFn = (req: HttpRequest, next: HttpHandler) => Promise<HttpResponse<unknown>>;
+export type BasicCredential = {
+	username: string;
+	password: string;
+};
+export type BasicAuthInterceptorOptions = {
+	encode?: (credential: BasicCredential) => string;
+};
+export declare function basicAuthInterceptor(fn: () => BasicCredential, options?: BasicAuthInterceptorOptions): InterceptorFn;
 export type HttpResponseType = "arraybuffer" | "blob" | "json" | "text";
 export interface HttpProgressEvent {
 	/**
@@ -83,7 +108,7 @@ export interface HttpProgressEvent {
 	readonly total: number;
 }
 export type HttpProgressFn = (event: HttpProgressEvent) => void;
-export type TransformRequestFn = (request: HttpRequest) => HttpRequest["body"];
+export type TransformRequestFn<Input = unknown> = (input: Input, request: HttpRequest) => HttpRequest["body"];
 export type TransformResponseFn<Output = unknown> = (response: HttpResponse<unknown>) => Output;
 export interface HttpRequest {
 	host?: string;
@@ -100,7 +125,11 @@ export interface HttpRequest {
 	/** when use fetch handler, no upload progress */
 	uploadProgress?: HttpProgressFn;
 	downloadProgress?: HttpProgressFn;
-	/** default：body */
+	/**
+	 * default：body
+	 *
+	 * @todo Implement streaming response
+	 */
 	observe?: "body" | "stream" | "response";
 	abort?: AbortSignal;
 }
@@ -125,7 +154,7 @@ export type RequestOptions<Output = unknown, Input extends Field<any> | Record<P
 export type DoRequestOptions = {
 	abort?: AbortSignal;
 	handler?: HttpHandler;
-	client?: ClientOptions;
+	client?: Client;
 	timeout?: number;
 };
 export type DoRequestFn<Input = unknown, Output = unknown> = Input extends undefined ? (options?: DoRequestOptions) => Promise<Output> : (input: RequestInputValue<Input>, options?: DoRequestOptions) => Promise<Output>;
@@ -150,7 +179,7 @@ export declare function defineRequest<Output = unknown, Input extends Field<any>
 	context?: HttpContext;
 	withCredentials?: boolean;
 	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
-	transformRequest?: TransformRequestFn;
+	transformRequest?: TransformRequestFn<RequestInputValue<Input>>;
 	transformResponse?: TransformResponseFn<Output>;
 }): UseRequestFn<Output, Input>;
 export declare function defineRequest<Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined>(options: {
@@ -163,7 +192,7 @@ export declare function defineRequest<Input extends Field<any> | Record<Property
 	context?: HttpContext;
 	withCredentials?: boolean;
 	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
-	transformRequest?: TransformRequestFn;
+	transformRequest?: TransformRequestFn<RequestInputValue<Input>>;
 	transformResponse?: TransformResponseFn;
 }): UseRequestFn<string, Input>;
 export declare function defineRequest<Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined>(options: {
@@ -176,7 +205,7 @@ export declare function defineRequest<Input extends Field<any> | Record<Property
 	context?: HttpContext;
 	withCredentials?: boolean;
 	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
-	transformRequest?: TransformRequestFn;
+	transformRequest?: TransformRequestFn<RequestInputValue<Input>>;
 	transformResponse?: TransformResponseFn;
 }): UseRequestFn<Blob, Input>;
 export declare function defineRequest<Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined>(options: {
@@ -189,7 +218,7 @@ export declare function defineRequest<Input extends Field<any> | Record<Property
 	context?: HttpContext;
 	withCredentials?: boolean;
 	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
-	transformRequest?: TransformRequestFn;
+	transformRequest?: TransformRequestFn<RequestInputValue<Input>>;
 	transformResponse?: TransformResponseFn;
 }): UseRequestFn<ArrayBuffer, Input>;
 /** Observe: Response */
@@ -203,7 +232,7 @@ export declare function defineRequest<Output = unknown, Input extends Field<any>
 	context?: HttpContext;
 	withCredentials?: boolean;
 	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
-	transformRequest?: TransformRequestFn;
+	transformRequest?: TransformRequestFn<RequestInputValue<Input>>;
 	transformResponse?: TransformResponseFn<Output>;
 }): UseRequestFn<HttpResponse<Output>, Input>;
 export declare function defineRequest<Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined>(options: {
@@ -216,7 +245,7 @@ export declare function defineRequest<Input extends Field<any> | Record<Property
 	context?: HttpContext;
 	withCredentials?: boolean;
 	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
-	transformRequest?: TransformRequestFn;
+	transformRequest?: TransformRequestFn<RequestInputValue<Input>>;
 	transformResponse?: TransformResponseFn;
 }): UseRequestFn<HttpResponse<string>, Input>;
 export declare function defineRequest<Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined>(options: {
@@ -229,7 +258,7 @@ export declare function defineRequest<Input extends Field<any> | Record<Property
 	context?: HttpContext;
 	withCredentials?: boolean;
 	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
-	transformRequest?: TransformRequestFn;
+	transformRequest?: TransformRequestFn<RequestInputValue<Input>>;
 	transformResponse?: TransformResponseFn;
 }): UseRequestFn<HttpResponse<Blob>, Input>;
 export declare function defineRequest<Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined>(options: {
@@ -242,10 +271,28 @@ export declare function defineRequest<Input extends Field<any> | Record<Property
 	context?: HttpContext;
 	withCredentials?: boolean;
 	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
-	transformRequest?: TransformRequestFn;
+	transformRequest?: TransformRequestFn<RequestInputValue<Input>>;
 	transformResponse?: TransformResponseFn;
 }): UseRequestFn<HttpResponse<ArrayBuffer>, Input>;
 export type HttpHandler = (req: HttpRequest) => Promise<HttpResponse<unknown>>;
+export interface FetchConfig {
+	/** A string indicating how the request will interact with the browser's cache to set request's cache. */
+	cache?: RequestCache;
+	/** A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials. */
+	credentials?: RequestCredentials;
+	/** A boolean to set request's keepalive. */
+	keepalive?: boolean;
+	/** A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode. */
+	mode?: RequestMode;
+	priority?: RequestPriority;
+	/** A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect. */
+	redirect?: RequestRedirect;
+	/** A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer. */
+	referrer?: string;
+	/** A referrer policy to set request's referrerPolicy. */
+	referrerPolicy?: ReferrerPolicy;
+}
+export declare const FETCH_CONFIG_KEY: HttpContextToken<FetchConfig>;
 export declare function fetchHandler(httpRequest: HttpRequest): Promise<HttpResponse<unknown>>;
 export interface ClientOptions {
 	host: string;
@@ -263,6 +310,7 @@ export type Client = {} & {
 };
 export declare function isClient(value: unknown): value is Client;
 export declare function createClient(options: ClientOptions): Client;
+export declare function cloneClient(client: Client, options: ClientOptions): Client;
 export declare function getGlobalClient(): Client;
 export declare function setGlobalClient(client: Client): void;
 export declare function restGlobalClient(): void;

package/{dist/index.js → index.js}

@@ -1,21 +1,31 @@
 // src/context.ts
 function makeHttpContextToken(defaultValue) {
+  Object.defineProperty(defaultValue, HTTP_CONTEXT_TOKEN, { value: defaultValue });
   return defaultValue;
 }
+function isHttpContextToken(value) {
+  return typeof value === "function" && HTTP_CONTEXT_TOKEN in value;
+}
 function makeHttpContext() {
   const ctx = new Map;
   return {
     set(token, value) {
+      if (!isHttpContextToken(token)) {
+        throw new Error("Invalid HttpContextToken");
+      }
       ctx.set(token, value);
       return this;
     },
     get(token) {
+      if (!isHttpContextToken(token)) {
+        throw new Error("Invalid HttpContextToken");
+      }
       if (!ctx.has(token)) {
         ctx.set(token, token());
       }
       return ctx.get(token);
     },
-    delete(token) {
+    del(token) {
       ctx.delete(token);
       return this;
     },
@@ -27,6 +37,7 @@ function makeHttpContext() {
     }
   };
 }
+var HTTP_CONTEXT_TOKEN = Symbol("HttpContextToken");
 
 // src/field.ts
 function field(defaultValue) {
@@ -76,6 +87,22 @@ 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;
+    }
+  }
+}
 function isField(value) {
   return !!value && typeof value === "function" && FIELD in value;
 }
@@ -88,13 +115,49 @@ var FIELD = Symbol("field");
 var globalHttpHandler = undefined;
 var getGlobalHttpHandler = () => globalHttpHandler;
 
-// src/interceptor.ts
+// 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));
 }
 
+// src/response.ts
+function isHttpResponse(value) {
+  return typeof value === "object" && value !== null && HTTP_RESPONSE in value;
+}
+function makeResponse(options) {
+  const status = options.status ?? 0;
+  const statusText = options.statusText ?? "";
+  const ok = status >= 200 && status < 300;
+  const url = options.url ?? "";
+  const headers = options.headers ?? new Headers;
+  const body = options.body ?? null;
+  if (!ok || options.error) {
+    const error = options.error || new Error(`Http failure response for ${options.url}: ${status} ${statusText}`);
+    return {
+      ok: false,
+      error,
+      status,
+      statusText,
+      url,
+      headers,
+      body: null,
+      [HTTP_RESPONSE]: null
+    };
+  }
+  return {
+    ok: true,
+    status,
+    statusText,
+    url,
+    headers,
+    body,
+    [HTTP_RESPONSE]: null
+  };
+}
+var HTTP_RESPONSE = Symbol("HTTP_RESPONSE");
+
 // src/request.ts
 function serializeBody(body) {
   switch (true) {
@@ -163,17 +226,31 @@ function defineRequest(options) {
     const setDownloadProgress = (fn) => {
       downloadProgress = fn;
     };
-    const doRequest = async (input, options2) => {
+    const doRequest = async (...args) => {
+      let input;
+      let doRequestOptions;
+      switch (args.length) {
+        case 1: {
+          doRequestOptions = args[0];
+          break;
+        }
+        case 2: {
+          input = args[0];
+          doRequestOptions = args[1];
+          break;
+        }
+      }
       if (requiredInput && !input) {
         throw new Error("input is required");
       }
-      if (options2?.abort) {
-        abortSignal = options2.abort;
+      if (doRequestOptions?.abort) {
+        abortSignal = doRequestOptions.abort;
       } else {
         abortController = new AbortController;
         abortSignal = abortController.signal;
       }
-      const clientOptions = getClientConfig(options2?.client || getGlobalClient());
+      const client2 = isClient(doRequestOptions?.client) ? doRequestOptions.client : getGlobalClient();
+      const clientOptions = getClientConfig(client2);
       const req = {
         host: clientOptions?.host,
         method: requestOptions.method,
@@ -187,10 +264,10 @@ function defineRequest(options) {
         observe: requestOptions.observe ?? "body",
         uploadProgress,
         downloadProgress,
-        timeout: options2?.timeout || 0,
+        timeout: doRequestOptions?.timeout || 0,
         abort: abortSignal
       };
-      const handler2 = options2?.handler || clientOptions?.handler || getGlobalHttpHandler();
+      const handler2 = doRequestOptions?.handler || clientOptions?.handler || getGlobalHttpHandler();
       if (!handler2) {
         throw new Error("no handler");
       }
@@ -198,7 +275,7 @@ function defineRequest(options) {
         await fillRequestFromField(req, requestOptions.input, input);
       }
       if (typeof requestOptions.transformRequest === "function") {
-        req.body = requestOptions.transformRequest(req);
+        req.body = requestOptions.transformRequest(input, req);
       }
       const chain = makeInterceptorChain([...clientOptions?.interceptors || [], ...requestOptions?.interceptors || []]);
       if (typeof req.timeout === "number" && req.timeout > 0 && abortController) {
@@ -208,9 +285,26 @@ function defineRequest(options) {
           }
         }, req.timeout);
       }
-      const res = await chain(req, handler2);
+      let res;
+      try {
+        res = await chain(req, handler2);
+      } catch (error) {
+        throw makeResponse({
+          error: error instanceof Error ? error : new Error("Transform response error", { cause: error })
+        });
+      }
       if (typeof requestOptions.transformResponse === "function") {
-        res.body = requestOptions.transformResponse(res);
+        try {
+          res = makeResponse({
+            ...res,
+            body: requestOptions.transformResponse(res)
+          });
+        } catch (error) {
+          throw makeResponse({
+            ...res,
+            error: error instanceof Error ? error : new Error("Transform response error", { cause: error })
+          });
+        }
       }
       switch (req.observe) {
         case "body":
@@ -384,75 +478,24 @@ async function fillRequestFromField(request, fieldOrFieldGroup, input) {
   throw new Error("unsupported field type");
 }
 
-// src/response.ts
-function makeResponse(options) {
-  const status = options.status ?? 0;
-  const statusText = options.statusText ?? "";
-  const ok = status >= 200 && status < 300;
-  const url = options.url ?? "";
-  const headers = options.headers ?? new Headers;
-  const body = options.body ?? null;
-  if (!ok || options.error) {
-    const error = options.error || new Error(`Http failure response for ${options.url}: ${status} ${statusText}`);
-    return {
-      ok: false,
-      error,
-      status,
-      statusText,
-      url,
-      headers,
-      body
-    };
-  }
-  return {
-    ok: true,
-    status,
-    statusText,
-    url,
-    headers,
-    body
-  };
-}
-
-// src/handler/fetch/fetch.ts
-function createRequest(request2) {
-  const url = new URL(request2.endpoint, request2.host);
-  if (request2.queryParams) {
-    url.search = request2.queryParams.toString();
+// src/handler/util.ts
+function getContentLength(headers) {
+  const value = headers.get("Content-Length");
+  if (!value) {
+    return 0;
   }
-  if (request2.headers) {
-    if (!request2.headers.has("Content-Type")) {
-      const detectedType = detectContentTypeHeader(request2.body);
-      if (detectedType) {
-        request2.headers.set("Content-Type", detectedType);
-      }
-    }
-    if (!request2.headers.has("Accept")) {
-      request2.headers.set("Accept", "application/json, text/plain, */*");
-    }
+  const num = Number(value);
+  if (isNaN(num)) {
+    return 0;
   }
-  const credentials = request2.withCredentials ? "include" : undefined;
-  const fetchConfig = request2.context?.get(FETCH_CONFIG_KEY) || {};
-  return new Request(url, {
-    ...fetchConfig,
-    headers: request2.headers,
-    method: request2.method,
-    body: serializeBody(request2.body),
-    signal: request2.abort,
-    credentials
-  });
+  return num;
 }
-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;
+function getContentType(headers) {
+  return headers.get("Content-Type") || "";
 }
-function parseBody(request2, response2, content) {
-  const responseType = request2.responseType;
+function parseBody(params) {
+  const { request, content, contentType } = params;
+  const responseType = request.responseType;
   if (!responseType) {
     return null;
   }
@@ -467,7 +510,6 @@ function parseBody(request2, response2, content) {
     case "text":
       return new TextDecoder().decode(content);
     case "blob": {
-      const contentType = response2.headers.get("Content-Type") || undefined;
       return new Blob([content], { type: contentType });
     }
     case "arraybuffer":
@@ -476,35 +518,59 @@ function parseBody(request2, response2, content) {
       return null;
   }
 }
-function getContentLength(headers) {
-  const value = headers.get("Content-Length");
-  if (!value) {
-    return 0;
+function concatChunks(chunks, totalLength) {
+  const chunksAll = new Uint8Array(totalLength);
+  let position = 0;
+  for (const chunk of chunks) {
+    chunksAll.set(chunk, position);
+    position += chunk.length;
   }
-  const num = Number(value);
-  if (isNaN(num)) {
-    return 0;
+  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();
   }
-  return num;
+  const headers = request2.headers ?? new Headers;
+  if (!headers.has("Content-Type")) {
+    const detectedType = detectContentTypeHeader(request2.body);
+    if (detectedType) {
+      headers.set("Content-Type", detectedType);
+    }
+  }
+  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) || {};
+  return new Request(url, {
+    ...fetchConfig,
+    headers,
+    method: request2.method,
+    body: serializeBody(request2.body),
+    signal: request2.abort,
+    credentials
+  });
 }
 async function fetchHandler(httpRequest) {
-  const { downloadProgress } = httpRequest;
+  const downloadProgress = httpRequest.downloadProgress;
   const request2 = createRequest(httpRequest);
-  let response2;
+  let response3;
   try {
-    response2 = await (globalThis || window).fetch(request2);
+    response3 = await (globalThis || window).fetch(request2);
   } catch (error) {
-    throw makeResponse({
-      error: error instanceof Error ? error : new Error("Network Error"),
-      url: request2.url
-    });
+    throw new Error("Network Error", { cause: error });
   }
-  const { headers, status, statusText, url } = response2;
+  const { headers, status, statusText, url } = response3;
   const contentLength = getContentLength(headers);
+  const contentType = getContentType(headers);
   let body = null;
-  if (response2.body) {
+  if (response3.body) {
     const chunks = [];
-    const reader = response2.body.getReader();
+    const reader = response3.body.getReader();
     let receivedLength = 0;
     while (true) {
       const { done, value } = await reader.read();
@@ -521,15 +587,13 @@ async function fetchHandler(httpRequest) {
     }
     const chunksAll = concatChunks(chunks, receivedLength);
     try {
-      body = parseBody(httpRequest, response2, chunksAll);
-    } catch (error) {
-      throw makeResponse({
-        error: new Error("Parse response body error", { cause: error }),
-        url,
-        status,
-        statusText,
-        headers
+      body = parseBody({
+        request: httpRequest,
+        content: chunksAll,
+        contentType
       });
+    } catch (error) {
+      throw new Error("Parse response body error", { cause: error });
     }
   }
   return makeResponse({
@@ -547,7 +611,7 @@ function isClient(value) {
 }
 function getClientConfig(client2) {
   if (!isClient(client2)) {
-    return null;
+    throw new Error("Invalid client");
   }
   return client2[CLIENT];
 }
@@ -561,6 +625,16 @@ function createClient(options) {
     [CLIENT]: conf
   };
 }
+function cloneClient(client2, options) {
+  const preConf = getClientConfig(client2);
+  const conf = {
+    ...preConf,
+    ...options
+  };
+  return {
+    [CLIENT]: conf
+  };
+}
 function getGlobalClient() {
   if (!globalClient) {
     throw new Error("Global client not set");
@@ -578,12 +652,110 @@ function createGlobalClient(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;
+    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;
+    headers.set("Authorization", `Basic ${encode(fn())}`);
+    req.headers = headers;
+    return next(req);
+  };
+}
+// src/validator.ts
+var required = (value) => {
+  if (!value) {
+    return new Error("required");
+  }
+  return null;
+};
+var requiredTrue = (value) => {
+  if (typeof value !== "boolean" || !value) {
+    return new Error("requiredTrue");
+  }
+  return null;
+};
+var minLength = (min) => {
+  return (value) => {
+    if (typeof value !== "string") {
+      return new Error("invalid string");
+    }
+    if (value.length < min) {
+      return new Error(`minLength ${min}`);
+    }
+    return null;
+  };
+};
+var maxLength = (max) => {
+  return (value) => {
+    if (typeof value !== "string") {
+      return new Error("invalid string");
+    }
+    if (value.length > max) {
+      return new Error(`maxLength ${max}`);
+    }
+    return null;
+  };
+};
+var min = (min2) => {
+  return (value) => {
+    if (typeof value !== "number" || isNaN(value)) {
+      return new Error("invalid number");
+    }
+    if (value < min2) {
+      return new Error(`minLength ${min2}`);
+    }
+    return null;
+  };
+};
+var max = (max2) => {
+  return (value) => {
+    if (typeof value !== "number" || isNaN(value)) {
+      return new Error("invalid number");
+    }
+    if (value > max2) {
+      return new Error(`maxLength ${max2}`);
+    }
+    return null;
+  };
+};
+var pattern = (pattern2) => {
+  return (value) => {
+    if (typeof value !== "string") {
+      return new Error("invalid string");
+    }
+    if (typeof pattern2 === "string") {
+      pattern2 = new RegExp(pattern2);
+    }
+    if (!pattern2.test(value)) {
+      return new Error("pattern");
+    }
+    return null;
+  };
+};
 export {
+  validatorField,
   setGlobalClient,
   restGlobalClient,
+  requiredTrue,
+  required,
+  pattern,
+  minLength,
+  min,
+  maxLength,
+  max,
   makeResponse,
   makeHttpContextToken,
   makeHttpContext,
+  isHttpResponse,
+  isHttpContextToken,
   isFieldGroup,
   isField,
   isClient,
@@ -592,5 +764,9 @@ export {
   fetchHandler,
   defineRequest,
   createGlobalClient,
-  createClient
+  createClient,
+  cloneClient,
+  basicAuthInterceptor,
+  asyncValidatorField,
+  FETCH_CONFIG_KEY
 };

package/package.json

@@ -1,25 +1,25 @@
 {
   "name": "@defjs/core",
-  "version": "0.0.0-test-0014",
+  "version": "0.0.0-test-000",
   "type": "module",
-  "scripts": {
-    "build": "bun run ./scripts/build.ts",
-    "test": "bun test",
-    "lint": "biome check",
-    "lint:fix": "biome check --write",
-    "pub": "npm publish"
+  "module": "index.js",
+  "typings": "index.d.ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/defjs/defjs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/defjs/defjs/issues"
   },
   "peerDependencies": {
-    "typescript": "^5.0"
+    "typescript": "^5.0.0"
   },
-  "files": ["dist"],
-  "module": "dist/index.js",
-  "typings": "dist/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "types": "./index.d.ts",
+      "default": "./index.js"
     }
   }
-}
+}