@defjs/core 0.0.0-test-0000

package/README.md

@@ -0,0 +1,5 @@
+## @defjs/defjs
+
+## Documentation
+
+Check out the [defjs.org](https://defjs.org) to get started.

package/dist/index.d.ts

@@ -0,0 +1,254 @@
+export type HttpContextToken<T> = () => T;
+export declare function makeHttpContextToken<T>(defaultValue: () => T): HttpContextToken<T>;
+export type HttpContext = {
+	set<T>(token: HttpContextToken<T>, value: T): HttpContext;
+	get<T>(token: HttpContextToken<T>): T;
+	delete(token: HttpContextToken<unknown>): HttpContext;
+	has(token: HttpContextToken<unknown>): boolean;
+	keys(): IterableIterator<HttpContextToken<unknown>>;
+};
+export declare function makeHttpContext(): HttpContext;
+export type ValidatorFn<T = unknown> = <I>(value: I | T) => Error | null | undefined;
+export type AsyncValidatorFn<T = unknown> = <I>(value: I | T) => Promise<Error | null | undefined>;
+declare const FIELD: unique symbol;
+declare enum FieldType {
+	Json = 1,
+	Query = 2,
+	Param = 3,
+	Header = 4,
+	Form = 5,
+	Body = 6
+}
+export interface FieldMetadata<T = undefined> {
+	alias: Map<FieldType, string | undefined>;
+	validators: ValidatorFn<T>[];
+	asyncValidator: AsyncValidatorFn<T>[];
+}
+export type Field<T = undefined> = (() => T) & {
+	withJson(alias?: string): Field<T>;
+	withForm(alias?: string): Field<T>;
+	withQuery(alias?: string): Field<T>;
+	withParam(alias?: string): Field<T>;
+	withHeader(alias?: string): Field<T>;
+	withBody(): Field<T>;
+	withValidators(...fn: ValidatorFn<T>[]): Field<T>;
+	withAsyncValidators(...fn: AsyncValidatorFn<T>[]): Field<T>;
+	readonly [FIELD]: FieldMetadata<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 isField(value: unknown): value is Field;
+export declare function isFieldGroup(value: unknown): value is Record<PropertyKey, Field>;
+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;
+} | {
+	ok: false;
+	error: Error;
+	status: number;
+	statusText: string;
+	url: string;
+	headers: Headers;
+	body: R | null;
+};
+export type MakeResponseOptions<R> = {
+	status?: number;
+	statusText?: string;
+	url?: string;
+	headers?: Headers;
+	body?: R | null;
+	error?: Error;
+};
+export declare function makeResponse<R>(options: MakeResponseOptions<R>): HttpResponse<R>;
+export type InterceptorFn = (req: HttpRequest, next: HttpHandler) => Promise<HttpResponse<unknown>>;
+export type HttpResponseType = "arraybuffer" | "blob" | "json" | "text";
+export interface HttpProgressEvent {
+	/** 表示 Progress 所关联的资源是否具有可以计算的长度。否则，Progress.total 属性将是一个无意义的值 */
+	readonly lengthComputable: boolean;
+	/** 表示底层的进程已经执行的工作量 */
+	readonly loaded: number;
+	/** 正在处理或者传输的数据的总大小. 如果 Progress.lengthComputable 属性是 false，这个值是没有意义的并且应该被忽略 */
+	readonly total: number;
+}
+export type HttpProgressFn = (value: HttpProgressEvent) => void;
+export type TransformRequestFn = (request: HttpRequest) => HttpRequest["body"];
+export type TransformResponseFn<Output = unknown> = (response: HttpResponse<unknown>) => Output;
+export interface HttpRequest {
+	host?: string;
+	method: string;
+	endpoint: string;
+	body?: Blob | ArrayBuffer | FormData | object | string | number | boolean | null;
+	headers: Headers;
+	queryParams: URLSearchParams;
+	/** 默认：json */
+	responseType: HttpResponseType;
+	context: HttpContext;
+	timeout: number;
+	withCredentials?: boolean;
+	/** when use fetch handler, no upload progress */
+	uploadProgress?: HttpProgressFn;
+	downloadProgress?: HttpProgressFn;
+	/** 默认：body */
+	observe: "body" | "stream" | "response";
+	abort: AbortSignal;
+}
+export type RequestInputValue<T> = T extends Field<infer V> ? V : T extends {
+	[K in keyof T]: Field<any>;
+} ? {
+	[K in keyof T]: RequestInputValue<T[K]>;
+} : never;
+export type RequestOptions<Output = unknown, Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined> = {
+	method: string;
+	endpoint: string;
+	input?: Input;
+	interceptors?: InterceptorFn[];
+	responseType?: HttpResponseType;
+	context?: HttpContext;
+	observe?: "body" | "response";
+	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
+	transformRequest?: TransformRequestFn;
+	transformResponse?: TransformResponseFn<Output>;
+};
+declare const REQUEST_REF: unique symbol;
+export type RequestRef<_Output = undefined, _Input = undefined> = {
+	readonly [REQUEST_REF]: RequestOptions;
+};
+export type MakeRequestFn<Output = undefined, Input = undefined> = () => RequestRef<Output, Input>;
+/** Observe: Body */
+export declare function defineRequest<Output = unknown, Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined>(options: {
+	method: string;
+	endpoint: string;
+	input?: Input;
+	interceptors?: InterceptorFn[];
+	responseType?: "json";
+	observe?: "body";
+	context?: HttpContext;
+	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
+	transformRequest?: TransformRequestFn;
+	transformResponse?: TransformResponseFn<Output>;
+}): MakeRequestFn<Output, Input>;
+export declare function defineRequest<Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined>(options: {
+	method: string;
+	endpoint: string;
+	input?: Input;
+	interceptors?: InterceptorFn[];
+	responseType: "text";
+	observe?: "body";
+	context?: HttpContext;
+	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
+	transformRequest?: TransformRequestFn;
+	transformResponse?: TransformResponseFn;
+}): MakeRequestFn<string, Input>;
+export declare function defineRequest<Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined>(options: {
+	method: string;
+	endpoint: string;
+	input?: Input;
+	interceptors?: InterceptorFn[];
+	responseType: "blob";
+	observe?: "body";
+	context?: HttpContext;
+	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
+	transformRequest?: TransformRequestFn;
+	transformResponse?: TransformResponseFn;
+}): MakeRequestFn<Blob, Input>;
+export declare function defineRequest<Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined>(options: {
+	method: string;
+	endpoint: string;
+	input?: Input;
+	interceptors?: InterceptorFn[];
+	responseType: "arraybuffer";
+	observe?: "body";
+	context?: HttpContext;
+	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
+	transformRequest?: TransformRequestFn;
+	transformResponse?: TransformResponseFn;
+}): MakeRequestFn<ArrayBuffer, Input>;
+/** Observe: Response */
+export declare function defineRequest<Output = unknown, Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined>(options: {
+	method: string;
+	endpoint: string;
+	input?: Input;
+	interceptors?: InterceptorFn[];
+	responseType?: "json";
+	observe: "response";
+	context?: HttpContext;
+	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
+	transformRequest?: TransformRequestFn;
+	transformResponse?: TransformResponseFn<Output>;
+}): MakeRequestFn<HttpResponse<Output>, Input>;
+export declare function defineRequest<Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined>(options: {
+	method: string;
+	endpoint: string;
+	input?: Input;
+	interceptors?: InterceptorFn[];
+	responseType?: "text";
+	observe: "response";
+	context?: HttpContext;
+	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
+	transformRequest?: TransformRequestFn;
+	transformResponse?: TransformResponseFn;
+}): MakeRequestFn<HttpResponse<string>, Input>;
+export declare function defineRequest<Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined>(options: {
+	method: string;
+	endpoint: string;
+	input?: Input;
+	interceptors?: InterceptorFn[];
+	responseType: "blob";
+	observe: "response";
+	context?: HttpContext;
+	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
+	transformRequest?: TransformRequestFn;
+	transformResponse?: TransformResponseFn;
+}): MakeRequestFn<HttpResponse<Blob>, Input>;
+export declare function defineRequest<Input extends Field<any> | Record<PropertyKey, Field<any>> | undefined = undefined>(options: {
+	method: string;
+	endpoint: string;
+	input?: Input;
+	interceptors?: InterceptorFn[];
+	responseType?: "arraybuffer";
+	observe: "response";
+	context?: HttpContext;
+	validators?: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[];
+	transformRequest?: TransformRequestFn;
+	transformResponse?: TransformResponseFn;
+}): MakeRequestFn<HttpResponse<ArrayBuffer>, Input>;
+export declare function isRequestRef(value: unknown): value is RequestRef;
+export type DoRequestOptions = {
+	uploadProgress?: HttpProgressFn;
+	downloadProgress?: HttpProgressFn;
+	abort?: AbortSignal;
+	handler?: HttpHandler;
+	client?: ClientOptions;
+	timeout?: number;
+};
+export type RequestRefOutput<T> = T extends RequestRef<infer O> ? O : undefined;
+export type RequestRefInput<T> = T extends RequestRef<unknown, infer I> ? RequestInputValue<I> : never;
+export type RequestRefWithInput<T> = T extends RequestRef<unknown, infer Input> ? (Input extends undefined ? false : true) : false;
+export declare function doRequest<Ref extends RequestRef>(ref: RequestRefWithInput<Ref> extends true ? never : Ref, options?: DoRequestOptions): Promise<RequestRefOutput<Ref>>;
+export declare function doRequest<Ref extends RequestRef>(ref: RequestRefWithInput<Ref> extends true ? Ref : never, input: RequestRefInput<Ref>, options?: DoRequestOptions): Promise<RequestRefOutput<Ref>>;
+export type HttpHandler = (req: HttpRequest) => Promise<HttpResponse<unknown>>;
+export declare const fetchHandler: HttpHandler;
+export interface ClientOptions {
+	host: string;
+	interceptors?: InterceptorFn[];
+	handler?: HttpHandler;
+}
+export interface ClientConfig {
+	host: string;
+	handler: HttpHandler;
+	interceptors?: InterceptorFn[];
+}
+declare const CLIENT: unique symbol;
+export type Client = {} & {
+	readonly [CLIENT]: ClientConfig;
+};
+export declare function isClient(value: any): value is Client;
+export declare function createClient(options: ClientOptions): Client;
+
+export {};

package/dist/index.js

@@ -0,0 +1,562 @@
+// src/context.ts
+function makeHttpContextToken(defaultValue) {
+  return defaultValue;
+}
+function makeHttpContext() {
+  const ctx = new Map;
+  return {
+    set(token, value) {
+      ctx.set(token, value);
+      return this;
+    },
+    get(token) {
+      if (!ctx.has(token)) {
+        ctx.set(token, token());
+      }
+      return ctx.get(token);
+    },
+    delete(token) {
+      ctx.delete(token);
+      return this;
+    },
+    has(token) {
+      return ctx.has(token);
+    },
+    keys() {
+      return ctx.keys();
+    }
+  };
+}
+
+// src/field.ts
+function field(defaultValue) {
+  const meta = {
+    alias: new Map,
+    validators: [],
+    asyncValidator: []
+  };
+  const getter = () => defaultValue;
+  Object.defineProperty(getter, FIELD, {
+    value: meta
+  });
+  getter.withJson = (alias) => {
+    meta.alias.set(1 /* Json */, alias);
+    return getter;
+  };
+  getter.withForm = (alias) => {
+    meta.alias.set(5 /* Form */, alias);
+    return getter;
+  };
+  getter.withQuery = (alias) => {
+    meta.alias.set(2 /* Query */, alias);
+    return getter;
+  };
+  getter.withParam = (alias) => {
+    meta.alias.set(3 /* Param */, alias);
+    return getter;
+  };
+  getter.withHeader = (alias) => {
+    meta.alias.set(4 /* Header */, alias);
+    return getter;
+  };
+  getter.withBody = () => {
+    meta.alias.set(6 /* Body */, undefined);
+    return getter;
+  };
+  getter.withValidators = (...fn) => {
+    meta.validators = fn;
+    return getter;
+  };
+  getter.withAsyncValidators = (...fn) => {
+    meta.asyncValidator = fn;
+    return getter;
+  };
+  return getter;
+}
+function getFieldMetadata(field2) {
+  return field2[FIELD];
+}
+function isField(value) {
+  return !!value && typeof value === "function" && FIELD in 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;
+
+// src/interceptor.ts
+function makeInterceptorChain(interceptors) {
+  return interceptors.reduceRight((fn, interceptor) => {
+    return (initReq, finalHandlerFn) => interceptor(initReq, (req) => fn(req, finalHandlerFn));
+  }, (req, fn) => fn(req));
+}
+
+// src/request.ts
+function serializeBody(body) {
+  switch (true) {
+    case body instanceof FormData:
+    case body instanceof Blob:
+    case body instanceof ArrayBuffer:
+    case typeof body === "string":
+      return body;
+    case typeof body === "object":
+    case typeof body === "boolean":
+    case typeof body === "number":
+    case Array.isArray(body):
+      return JSON.stringify(body);
+    default:
+      return null;
+  }
+}
+function detectContentTypeHeader(body) {
+  switch (true) {
+    case body instanceof FormData:
+      return "multipart/form-data";
+    case body instanceof ArrayBuffer:
+      return "application/octet-stream";
+    case body instanceof Blob: {
+      return body.type || "application/octet-stream";
+    }
+    case body instanceof URLSearchParams: {
+      return "application/x-www-form-urlencoded;charset=UTF-8";
+    }
+    case typeof body === "string":
+      return "text/plain";
+    case (typeof body === "object" && body !== null):
+    case typeof body === "number":
+    case typeof body === "boolean":
+      return "application/json";
+    default:
+      return null;
+  }
+}
+function defineRequest(options) {
+  return () => {
+    const opts = {
+      ...options
+    };
+    const ref = {};
+    Object.defineProperty(ref, REQUEST_REF, {
+      value: opts
+    });
+    return ref;
+  };
+}
+function isRequestRef(value) {
+  return !!value && typeof value === "object" && REQUEST_REF in value;
+}
+function getRequestRefOptions(value) {
+  if (!isRequestRef(value)) {
+    throw new Error("no request ref");
+  }
+  return value[REQUEST_REF];
+}
+function throwAliaNotSet() {
+  throw new Error("alias not set");
+}
+function fillUrl(endpoint, params) {
+  for (const [key, value] of params) {
+    endpoint = endpoint.replace(`:${key}`, value.toString());
+  }
+  return endpoint;
+}
+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;
+  }
+  if (isField(fieldOrFieldGroup)) {
+    const param = new Map;
+    const queryParams = new URLSearchParams;
+    const headers = new Headers;
+    let body = undefined;
+    const fieldValue = input ?? fieldOrFieldGroup();
+    const meta = getFieldMetadata(fieldOrFieldGroup);
+    const err = await doValid([...meta.validators, ...meta.asyncValidator], fieldValue);
+    if (err) {
+      throw err;
+    }
+    for (const [type, aliasName] of meta.alias) {
+      switch (type) {
+        case 1 /* Json */:
+          body = JSON.stringify(fieldValue);
+          break;
+        case 2 /* Query */: {
+          if (!aliasName) {
+            throwAliaNotSet();
+          }
+          queryParams.append(aliasName, String(fieldValue));
+          break;
+        }
+        case 3 /* Param */: {
+          if (!aliasName) {
+            throwAliaNotSet();
+          }
+          param.set(aliasName, String(fieldValue));
+          break;
+        }
+        case 4 /* Header */: {
+          if (!aliasName) {
+            throwAliaNotSet();
+          }
+          headers.set(aliasName, String(fieldValue));
+          break;
+        }
+        case 5 /* Form */: {
+          if (!aliasName) {
+            throwAliaNotSet();
+          }
+          const form = new FormData;
+          form.append(aliasName, String(fieldValue));
+          body = form;
+          break;
+        }
+        case 6 /* Body */:
+          body = fieldValue;
+          break;
+      }
+    }
+    request.endpoint = fillUrl(request.endpoint, param);
+    request.queryParams = queryParams;
+    request.headers = headers;
+    request.body = body;
+    return;
+  }
+  if (isFieldGroup(fieldOrFieldGroup) && inputIsObject(input)) {
+    const param = new Map;
+    const queryParams = new URLSearchParams;
+    const headers = new Headers;
+    const formData = new FormData;
+    const json = {};
+    let body = undefined;
+    for (const [propertyKey, field3] of Object.entries(fieldOrFieldGroup)) {
+      const defaultValue = field3();
+      const meta = getFieldMetadata(field3);
+      for (const [type, aliasName] of meta.alias) {
+        const valueKey = aliasName || propertyKey;
+        const value = input[valueKey] || defaultValue;
+        const err = await doValid([...meta.validators, ...meta.asyncValidator], value);
+        if (err) {
+          throw err;
+        }
+        switch (type) {
+          case 1 /* Json */:
+            Object.defineProperty(json, valueKey, {
+              value,
+              writable: true
+            });
+            break;
+          case 2 /* Query */:
+            queryParams.append(valueKey, value);
+            break;
+          case 3 /* Param */:
+            param.set(valueKey, value);
+            break;
+          case 4 /* Header */:
+            headers.set(valueKey, value);
+            break;
+          case 5 /* Form */:
+            formData.append(valueKey, value);
+            break;
+          case 6 /* Body */:
+            body = value;
+            break;
+        }
+      }
+      request.endpoint = fillUrl(request.endpoint, param);
+      request.queryParams = queryParams;
+      request.headers = headers;
+      if (body) {
+        request.body = body;
+      } else if (Array.from(formData.keys()).length > 0) {
+        request.body = formData;
+      } else if (Object.keys(json).length) {
+        request.body = JSON.stringify(json);
+      }
+    }
+    return;
+  }
+  throw new Error("unsupported field type");
+}
+async function doRequest(...args) {
+  const argsLength = args.length;
+  let ref;
+  let input;
+  let options = {};
+  switch (argsLength) {
+    case 2: {
+      ref = args[0];
+      options = args[1];
+      break;
+    }
+    case 3: {
+      ref = args[0];
+      input = args[1];
+      options = args[2];
+      break;
+    }
+    default: {
+      throw new Error("invalid arguments");
+    }
+  }
+  const requestOptions = getRequestRefOptions(ref);
+  const requiredInput = !!requestOptions.input;
+  if (requiredInput && !input) {
+    throw new Error("input is required");
+  }
+  let abortController;
+  let abortSignal;
+  if (options.abort) {
+    abortSignal = options.abort;
+  } else {
+    abortController = new AbortController;
+    abortSignal = abortController.signal;
+  }
+  const clientOptions = getClientConfig(options.client);
+  const req = {
+    host: clientOptions?.host || "",
+    method: requestOptions.method,
+    endpoint: requestOptions.endpoint,
+    queryParams: new URLSearchParams,
+    headers: new Headers,
+    body: undefined,
+    responseType: requestOptions.responseType ?? "json",
+    context: requestOptions.context || makeHttpContext(),
+    observe: requestOptions.observe ?? "body",
+    uploadProgress: options.uploadProgress,
+    downloadProgress: options.downloadProgress,
+    timeout: options.timeout || 0,
+    abort: abortSignal
+  };
+  let handler2;
+  if (options.handler) {
+    handler2 = options.handler;
+  } else if (clientOptions?.handler) {
+    handler2 = clientOptions.handler;
+  } else {
+    handler2 = getGlobalHttpHandler();
+  }
+  if (!handler2) {
+    throw new Error("no handler");
+  }
+  await fillRequestFromField(req, requestOptions.input, input);
+  if (typeof requestOptions.transformRequest === "function") {
+    req.body = requestOptions.transformRequest(req);
+  }
+  const chain = makeInterceptorChain([...clientOptions?.interceptors || [], ...requestOptions?.interceptors || []]);
+  if (req.timeout > 0 && abortController) {
+    setTimeout(() => {
+      if (!req.abort.aborted) {
+        abortController.abort("timeout");
+      }
+    }, req.timeout);
+  }
+  const res = await chain(req, handler2);
+  if (typeof requestOptions.transformResponse === "function") {
+    res.body = requestOptions.transformResponse(res);
+  }
+  return res;
+}
+var REQUEST_REF = Symbol("RequestRef");
+
+// 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) {
+    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);
+  url.search = request2.queryParams.toString();
+  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 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
+  });
+}
+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 parseBody(request2, response2, content) {
+  const responseType = request2.responseType;
+  if (!responseType) {
+    return null;
+  }
+  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": {
+      const contentType = response2.headers.get("Content-Type") || undefined;
+      return new Blob([content], { type: contentType });
+    }
+    case "arraybuffer":
+      return content.buffer;
+    default:
+      return null;
+  }
+}
+function getContentLength(headers) {
+  const value = headers.get("Content-Length");
+  if (!value) {
+    return 0;
+  }
+  const num = Number(value);
+  if (isNaN(num)) {
+    return 0;
+  }
+  return num;
+}
+async function _request(httpRequest) {
+  const request2 = createRequest(httpRequest);
+  const downloadProgress = httpRequest.downloadProgress;
+  let response2;
+  try {
+    response2 = await (globalThis || window).fetch(request2);
+  } catch (error) {
+    throw makeResponse({
+      error: error instanceof Error ? error : new Error("Unknown Error"),
+      url: request2.url
+    });
+  }
+  const { headers, status, statusText, url } = response2;
+  const contentLength = getContentLength(headers);
+  let body = null;
+  if (response2.body) {
+    const chunks = [];
+    const reader = response2.body.getReader();
+    let receivedLength = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      chunks.push(value);
+      receivedLength += value.length;
+      downloadProgress?.({
+        lengthComputable: contentLength > 0,
+        loaded: receivedLength,
+        total: contentLength
+      });
+      const chunksAll = concatChunks(chunks, receivedLength);
+      try {
+        body = parseBody(httpRequest, response2, chunksAll);
+      } catch (error) {
+        throw makeResponse({
+          error: error instanceof Error ? error : new Error("Unknown Error"),
+          url,
+          status,
+          statusText,
+          headers
+        });
+      }
+    }
+  }
+  return makeResponse({
+    url,
+    status,
+    statusText,
+    headers,
+    body
+  });
+}
+var FETCH_CONFIG_KEY = makeHttpContextToken(() => ({}));
+var fetchHandler = _request;
+// src/client.ts
+function isClient(value) {
+  return typeof value === "object" && CLIENT in value;
+}
+function getClientConfig(client2) {
+  if (!isClient(client2)) {
+    return null;
+  }
+  return client2[CLIENT];
+}
+function createClient(options) {
+  const conf = {
+    host: options.host,
+    interceptors: options.interceptors ?? [],
+    handler: options.handler || fetchHandler
+  };
+  return {
+    [CLIENT]: conf
+  };
+}
+var CLIENT = Symbol("Client");
+export {
+  makeResponse,
+  makeHttpContextToken,
+  makeHttpContext,
+  isRequestRef,
+  isFieldGroup,
+  isField,
+  isClient,
+  field,
+  fetchHandler,
+  doRequest,
+  defineRequest,
+  createClient
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+	"name": "@defjs/core",
+	"version": "0.0.0-test-0000",
+	"type": "module",
+	"scripts": {
+		"build": "bun run ./scripts/build.ts",
+		"test": "bun test",
+		"lint": "biome check",
+		"lint:fix": "biome check --write",
+		"pub": "npm publish"
+	},
+	"peerDependencies": {
+		"typescript": "^5.0"
+	},
+	"files": ["dist"],
+	"module": "dist/index.js",
+	"typings": "dist/index.d.ts",
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"types": "./index.d.ts",
+			"default": "./index.js"
+		}
+	}
+}