@ooneex/fetcher 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ooneex
+
+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/README.md

@@ -0,0 +1,573 @@
+# @ooneex/fetcher
+
+A powerful and flexible TypeScript/JavaScript HTTP client library built on top of the native Fetch API. This package provides a comprehensive set of methods for making HTTP requests with automatic JSON handling, header management, file uploads, and response status detection.
+
+![Browser](https://img.shields.io/badge/Browser-Compatible-green?style=flat-square&logo=googlechrome)
+![Bun](https://img.shields.io/badge/Bun-Compatible-orange?style=flat-square&logo=bun)
+![Deno](https://img.shields.io/badge/Deno-Compatible-blue?style=flat-square&logo=deno)
+![Node.js](https://img.shields.io/badge/Node.js-Compatible-green?style=flat-square&logo=node.js)
+![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue?style=flat-square&logo=typescript)
+![MIT License](https://img.shields.io/badge/License-MIT-yellow?style=flat-square)
+
+## Features
+
+✅ **Native Fetch Based** - Built on top of the modern Fetch API
+
+✅ **Type-Safe** - Full TypeScript support with proper type definitions
+
+✅ **HTTP Methods** - Support for GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS
+
+✅ **File Upload** - Built-in file and blob upload functionality
+
+✅ **Header Management** - Comprehensive header manipulation methods
+
+✅ **Authentication** - Bearer token and basic authentication support
+
+✅ **Request Aborting** - Built-in AbortController support
+
+✅ **Status Detection** - Automatic HTTP status code classification
+
+✅ **JSON Handling** - Automatic JSON serialization and deserialization
+
+✅ **Error Handling** - Comprehensive error handling and response parsing
+
+✅ **Cross-Platform** - Works in Browser, Node.js, Bun, and Deno
+
+✅ **Zero Dependencies** - Minimal external dependencies
+
+## Installation
+
+### Bun
+```bash
+bun add @ooneex/fetcher
+```
+
+### pnpm
+```bash
+pnpm add @ooneex/fetcher
+```
+
+### Yarn
+```bash
+yarn add @ooneex/fetcher
+```
+
+### npm
+```bash
+npm install @ooneex/fetcher
+```
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { Fetcher } from '@ooneex/fetcher';
+
+const api = new Fetcher('https://api.example.com');
+
+// GET request
+const response = await api.get('/users');
+console.log(response.data); // parsed JSON data
+console.log(response.isSuccessful); // true for 2xx status codes
+
+// POST request with JSON data
+const newUser = { name: 'John Doe', email: 'john@example.com' };
+const createResponse = await api.post('/users', newUser);
+```
+
+### Authentication
+
+```typescript
+import { Fetcher } from '@ooneex/fetcher';
+
+const api = new Fetcher('https://api.example.com');
+
+// Bearer token authentication
+api.setBearerToken('your-jwt-token');
+
+// Basic authentication
+api.setBasicToken('base64-encoded-credentials');
+
+// Make authenticated requests
+const response = await api.get('/protected-resource');
+
+// Clear authentication
+api.clearBearerToken();
+api.clearBasicToken();
+```
+
+### Header Management
+
+```typescript
+import { Fetcher } from '@ooneex/fetcher';
+
+const api = new Fetcher('https://api.example.com');
+
+// Set content type
+api.setContentType('application/json');
+
+// Set language
+api.setLang('en-US');
+
+// Chain header methods
+api.setBearerToken('token')
+   .setContentType('application/json')
+   .setLang('fr-FR');
+
+// Access header object directly
+api.header.set('X-Custom-Header', 'custom-value');
+```
+
+### File Upload
+
+```typescript
+import { Fetcher } from '@ooneex/fetcher';
+
+const api = new Fetcher('https://api.example.com');
+
+// Upload a file
+const fileInput = document.querySelector('input[type="file"]');
+const file = fileInput.files[0];
+
+const uploadResponse = await api.upload('/upload', file, 'document');
+
+// Upload a blob
+const blob = new Blob(['Hello, World!'], { type: 'text/plain' });
+const blobResponse = await api.upload('/upload-text', blob, 'textFile');
+```
+
+### Request Aborting
+
+```typescript
+import { Fetcher } from '@ooneex/fetcher';
+
+const api = new Fetcher('https://api.example.com');
+
+// Start a request
+const requestPromise = api.get('/slow-endpoint');
+
+// Abort the request
+api.abort();
+
+try {
+  const response = await requestPromise;
+} catch (error) {
+  console.log('Request was aborted');
+}
+```
+
+### Advanced Usage
+
+```typescript
+import { Fetcher } from '@ooneex/fetcher';
+
+const api = new Fetcher('https://api.example.com');
+
+// Configure headers and authentication
+api.setBearerToken('jwt-token')
+   .setContentType('application/json')
+   .setLang('en-US');
+
+// Make various HTTP requests
+const users = await api.get('/users');
+const user = await api.post('/users', { name: 'Jane Doe' });
+const updated = await api.put('/users/1', { name: 'Jane Smith' });
+const patched = await api.patch('/users/1', { email: 'jane@example.com' });
+await api.delete('/users/1');
+
+// Check response status
+if (user.isSuccessful) {
+  console.log('User created:', user.data);
+} else if (user.isClientError) {
+  console.log('Client error:', user.message);
+} else if (user.isServerError) {
+  console.log('Server error:', user.message);
+}
+
+// Clone fetcher for different configurations
+const authenticatedApi = api.clone().setBearerToken('different-token');
+```
+
+## API Reference
+
+### `Fetcher` Class
+
+The main class for making HTTP requests.
+
+#### Constructor
+
+##### `new Fetcher(baseURL: string)`
+Creates a new Fetcher instance with the specified base URL.
+
+**Parameters:**
+- `baseURL` - The base URL for all requests
+
+**Example:**
+```typescript
+const api = new Fetcher('https://api.example.com');
+```
+
+#### Authentication Methods
+
+##### `setBearerToken(token: string): Fetcher`
+Sets the Authorization header with a Bearer token.
+
+**Parameters:**
+- `token` - The Bearer token
+
+**Returns:** The Fetcher instance for method chaining
+
+**Example:**
+```typescript
+api.setBearerToken('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...');
+```
+
+##### `setBasicToken(token: string): Fetcher`
+Sets the Authorization header with Basic authentication.
+
+**Parameters:**
+- `token` - The base64-encoded credentials
+
+**Returns:** The Fetcher instance for method chaining
+
+**Example:**
+```typescript
+api.setBasicToken(btoa('username:password'));
+```
+
+##### `clearBearerToken(): Fetcher`
+Removes the Authorization header.
+
+**Returns:** The Fetcher instance for method chaining
+
+##### `clearBasicToken(): Fetcher`
+Removes the Authorization header.
+
+**Returns:** The Fetcher instance for method chaining
+
+#### Header Management Methods
+
+##### `setContentType(contentType: MimeType): Fetcher`
+Sets the Content-Type header.
+
+**Parameters:**
+- `contentType` - The MIME type for the content
+
+**Returns:** The Fetcher instance for method chaining
+
+**Example:**
+```typescript
+api.setContentType('application/json');
+api.setContentType('multipart/form-data');
+```
+
+##### `setLang(lang: string): Fetcher`
+Sets the Accept-Language header.
+
+**Parameters:**
+- `lang` - The language code
+
+**Returns:** The Fetcher instance for method chaining
+
+**Example:**
+```typescript
+api.setLang('en-US');
+api.setLang('fr-FR');
+```
+
+#### Request Control Methods
+
+##### `abort(): Fetcher`
+Aborts the current request and creates a new AbortController.
+
+**Returns:** The Fetcher instance for method chaining
+
+**Example:**
+```typescript
+api.abort(); // Cancels any ongoing requests
+```
+
+##### `clone(): Fetcher`
+Creates a new Fetcher instance with the same base URL.
+
+**Returns:** A new Fetcher instance
+
+**Example:**
+```typescript
+const newApi = api.clone();
+```
+
+#### HTTP Method Shortcuts
+
+##### `get<T = unknown>(path: string): Promise<FetcherResponseType<T>>`
+Performs a GET request.
+
+**Parameters:**
+- `path` - The endpoint path
+
+**Returns:** Promise resolving to a FetcherResponseType
+
+**Example:**
+```typescript
+const users = await api.get<User[]>('/users');
+```
+
+##### `post<T = unknown>(path: string, data?: unknown): Promise<FetcherResponseType<T>>`
+Performs a POST request.
+
+**Parameters:**
+- `path` - The endpoint path
+- `data` - Optional request body data
+
+**Returns:** Promise resolving to a FetcherResponseType
+
+**Example:**
+```typescript
+const newUser = await api.post<User>('/users', { name: 'John' });
+```
+
+##### `put<T = unknown>(path: string, data?: unknown): Promise<FetcherResponseType<T>>`
+Performs a PUT request.
+
+**Parameters:**
+- `path` - The endpoint path
+- `data` - Optional request body data
+
+**Returns:** Promise resolving to a FetcherResponseType
+
+**Example:**
+```typescript
+const updatedUser = await api.put<User>('/users/1', { name: 'Jane' });
+```
+
+##### `patch<T = unknown>(path: string, data?: unknown): Promise<FetcherResponseType<T>>`
+Performs a PATCH request.
+
+**Parameters:**
+- `path` - The endpoint path
+- `data` - Optional request body data
+
+**Returns:** Promise resolving to a FetcherResponseType
+
+**Example:**
+```typescript
+const patchedUser = await api.patch<User>('/users/1', { email: 'new@email.com' });
+```
+
+##### `delete<T = unknown>(path: string): Promise<FetcherResponseType<T>>`
+Performs a DELETE request.
+
+**Parameters:**
+- `path` - The endpoint path
+
+**Returns:** Promise resolving to a FetcherResponseType
+
+**Example:**
+```typescript
+await api.delete('/users/1');
+```
+
+##### `head<T = unknown>(path: string): Promise<FetcherResponseType<T>>`
+Performs a HEAD request.
+
+**Parameters:**
+- `path` - The endpoint path
+
+**Returns:** Promise resolving to a FetcherResponseType
+
+**Example:**
+```typescript
+const headers = await api.head('/users/1');
+```
+
+##### `options<T = unknown>(path: string): Promise<FetcherResponseType<T>>`
+Performs an OPTIONS request.
+
+**Parameters:**
+- `path` - The endpoint path
+
+**Returns:** Promise resolving to a FetcherResponseType
+
+**Example:**
+```typescript
+const options = await api.options('/users');
+```
+
+##### `request<T = unknown>(method: HttpMethodType, path: string, data?: unknown): Promise<FetcherResponseType<T>>`
+Performs a custom HTTP request.
+
+**Parameters:**
+- `method` - The HTTP method
+- `path` - The endpoint path
+- `data` - Optional request body data
+
+**Returns:** Promise resolving to a FetcherResponseType
+
+**Example:**
+```typescript
+const response = await api.request('PATCH', '/users/1', { status: 'active' });
+```
+
+##### `upload<T = unknown>(path: string, file: File | Blob, name?: string): Promise<FetcherResponseType<T>>`
+Uploads a file or blob.
+
+**Parameters:**
+- `path` - The endpoint path
+- `file` - The file or blob to upload
+- `name` - Optional field name (defaults to "file")
+
+**Returns:** Promise resolving to a FetcherResponseType
+
+**Example:**
+```typescript
+const fileInput = document.querySelector('input[type="file"]');
+const file = fileInput.files[0];
+const response = await api.upload('/upload', file, 'document');
+```
+
+#### Properties
+
+##### `header: Header`
+Read-only access to the Header instance for direct header manipulation.
+
+**Example:**
+```typescript
+api.header.set('X-API-Key', 'your-api-key');
+const contentType = api.header.get('Content-Type');
+```
+
+### Types
+
+#### `FetcherResponseType<T>`
+The response object returned by all HTTP methods.
+
+**Properties:**
+- `data: T | null` - The parsed response data
+- `message: string | null` - Error message if parsing failed
+- `header: ReadonlyHeader` - Response headers
+- `isInformational: boolean` - True for 1xx status codes
+- `isSuccessful: boolean` - True for 2xx status codes
+- `isRedirect: boolean` - True for 3xx status codes
+- `isClientError: boolean` - True for 4xx status codes
+- `isServerError: boolean` - True for 5xx status codes
+- `isError: boolean` - True for 4xx or 5xx status codes
+
+**Example:**
+```typescript
+const response = await api.get<User[]>('/users');
+
+if (response.isSuccessful) {
+  console.log('Users:', response.data);
+} else if (response.isClientError) {
+  console.error('Client error:', response.message);
+} else if (response.isServerError) {
+  console.error('Server error:', response.message);
+}
+```
+
+#### `IFetcher`
+Interface defining the Fetcher contract.
+
+**Example:**
+```typescript
+import { IFetcher } from '@ooneex/fetcher';
+
+class CustomFetcher implements IFetcher {
+  // Implement all required methods
+}
+```
+
+## Error Handling
+
+The fetcher automatically handles various error scenarios:
+
+```typescript
+import { Fetcher } from '@ooneex/fetcher';
+
+const api = new Fetcher('https://api.example.com');
+
+try {
+  const response = await api.get('/users');
+
+  if (response.isSuccessful) {
+    // Handle successful response
+    console.log('Data:', response.data);
+  } else if (response.isClientError) {
+    // Handle 4xx errors
+    console.error('Client error:', response.message);
+  } else if (response.isServerError) {
+    // Handle 5xx errors
+    console.error('Server error:', response.message);
+  }
+} catch (error) {
+  // Handle network errors or other exceptions
+  console.error('Request failed:', error);
+}
+```
+
+## Advanced Features
+
+### URL Building
+The fetcher automatically handles URL building:
+
+```typescript
+const api = new Fetcher('https://api.example.com');
+
+// These all work correctly
+await api.get('/users');           // -> https://api.example.com/users
+await api.get('users');            // -> https://api.example.com/users
+await api.get('https://other.com/api'); // -> https://other.com/api (absolute URL)
+
+// Base URL with trailing slash
+const api2 = new Fetcher('https://api.example.com/');
+await api2.get('/users');          // -> https://api.example.com/users
+```
+
+### Content Type Handling
+The fetcher automatically sets appropriate Content-Type headers:
+
+```typescript
+const api = new Fetcher('https://api.example.com');
+
+// Automatic JSON content type for objects
+await api.post('/users', { name: 'John' }); // Content-Type: application/json
+
+// FormData handling
+const formData = new FormData();
+formData.append('name', 'John');
+await api.post('/users', formData); // Content-Type: multipart/form-data
+
+// String data
+await api.post('/users', 'raw string data');
+
+// Blob/ArrayBuffer data
+const blob = new Blob(['data'], { type: 'text/plain' });
+await api.post('/upload', blob);
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+
+### Development Setup
+
+1. Clone the repository
+2. Install dependencies: `bun install`
+3. Run tests: `bun run test`
+4. Build the project: `bun run build`
+
+### Guidelines
+
+- Write tests for new features
+- Follow the existing code style
+- Update documentation for API changes
+- Ensure all tests pass before submitting PR
+
+---
+
+Made with ❤️ by the Ooneex team

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import { Header as Header2 } from "@ooneex/http-header";
+import { MimeType as MimeType2 } from "@ooneex/http-mimes";
+import { ResponseDataType as ResponseDataType2 } from "@ooneex/http-response";
+import { HttpMethodType as HttpMethodType2 } from "@ooneex/types";
+import { Header } from "@ooneex/http-header";
+import { MimeType } from "@ooneex/http-mimes";
+import { ResponseDataType } from "@ooneex/http-response";
+import { HttpMethodType } from "@ooneex/types";
+interface IFetcher {
+	readonly header: Header;
+	setBearerToken(token: string): IFetcher;
+	setBasicToken(token: string): IFetcher;
+	clearBearerToken(): IFetcher;
+	clearBasicToken(): IFetcher;
+	setContentType(contentType: MimeType): IFetcher;
+	setLang(lang: string): IFetcher;
+	abort(): IFetcher;
+	clone(): IFetcher;
+	get<T extends Record<string, unknown> = Record<string, unknown>>(path: string): Promise<ResponseDataType<T>>;
+	post<T extends Record<string, unknown> = Record<string, unknown>>(path: string, data?: unknown): Promise<ResponseDataType<T>>;
+	put<T extends Record<string, unknown> = Record<string, unknown>>(path: string, data?: unknown): Promise<ResponseDataType<T>>;
+	patch<T extends Record<string, unknown> = Record<string, unknown>>(path: string, data?: unknown): Promise<ResponseDataType<T>>;
+	delete<T extends Record<string, unknown> = Record<string, unknown>>(path: string): Promise<ResponseDataType<T>>;
+	head<T extends Record<string, unknown> = Record<string, unknown>>(path: string): Promise<ResponseDataType<T>>;
+	options<T extends Record<string, unknown> = Record<string, unknown>>(path: string): Promise<ResponseDataType<T>>;
+	request<T extends Record<string, unknown> = Record<string, unknown>>(method: HttpMethodType, path: string, data?: unknown): Promise<ResponseDataType<T>>;
+	upload<T extends Record<string, unknown> = Record<string, unknown>>(path: string, file: File | Blob, name?: string): Promise<ResponseDataType<T>>;
+}
+declare class Fetcher implements IFetcher {
+	private baseURL;
+	private abortController;
+	readonly header: Header2;
+	constructor(baseURL: string);
+	setBearerToken(token: string): this;
+	setBasicToken(token: string): this;
+	clearBearerToken(): this;
+	clearBasicToken(): this;
+	setContentType(contentType: MimeType2): this;
+	setLang(lang: string): this;
+	abort(): this;
+	clone(): Fetcher;
+	get<T extends Record<string, unknown> = Record<string, unknown>>(path: string): Promise<ResponseDataType2<T>>;
+	post<T extends Record<string, unknown> = Record<string, unknown>>(path: string, data?: unknown): Promise<ResponseDataType2<T>>;
+	put<T extends Record<string, unknown> = Record<string, unknown>>(path: string, data?: unknown): Promise<ResponseDataType2<T>>;
+	patch<T extends Record<string, unknown> = Record<string, unknown>>(path: string, data?: unknown): Promise<ResponseDataType2<T>>;
+	delete<T extends Record<string, unknown> = Record<string, unknown>>(path: string): Promise<ResponseDataType2<T>>;
+	head<T extends Record<string, unknown> = Record<string, unknown>>(path: string): Promise<ResponseDataType2<T>>;
+	options<T extends Record<string, unknown> = Record<string, unknown>>(path: string): Promise<ResponseDataType2<T>>;
+	request<T extends Record<string, unknown> = Record<string, unknown>>(method: HttpMethodType2, path: string, data?: unknown): Promise<ResponseDataType2<T>>;
+	upload<T extends Record<string, unknown> = Record<string, unknown>>(path: string, file: File | Blob, name?: string): Promise<ResponseDataType2<T>>;
+	private buildURL;
+	private buildRequestOptions;
+}
+export { IFetcher, Fetcher };

package/dist/index.js

@@ -0,0 +1,3 @@
+import{Header as c}from"@ooneex/http-header";class T{baseURL;abortController;header=new c;constructor(e){this.baseURL=e;this.abortController=new AbortController}setBearerToken(e){return this.header.setBearerToken(e),this}setBasicToken(e){return this.header.setBasicAuth(e),this}clearBearerToken(){return this.header.remove("Authorization"),this}clearBasicToken(){return this.header.remove("Authorization"),this}setContentType(e){return this.header.contentType(e),this}setLang(e){return this.header.setLang(e),this}abort(){return this.abortController.abort(),this.abortController=new AbortController,this}clone(){return new T(this.baseURL)}async get(e){return this.request("GET",e)}async post(e,n){return this.request("POST",e,n)}async put(e,n){return this.request("PUT",e,n)}async patch(e,n){return this.request("PATCH",e,n)}async delete(e){return this.request("DELETE",e)}async head(e){return this.request("HEAD",e)}async options(e){return this.request("OPTIONS",e)}async request(e,n,r){let s=this.buildURL(n),o=this.buildRequestOptions(e,r),i=await fetch(s,o);try{return await i.json()}catch(t){throw Error(t instanceof Error?t.message:"Failed to parse JSON response")}}async upload(e,n,r="file"){let s=new FormData;s.append(r,n);let o=this.header.get("Content-Type");this.header.remove("Content-Type");let i=await this.request("POST",e,s);if(o)this.header.set("Content-Type",o);return i}buildURL(e){if(e.startsWith("http://")||e.startsWith("https://"))return e;let n=e.startsWith("/")?e:`/${e}`;return`${this.baseURL.endsWith("/")?this.baseURL.slice(0,-1):this.baseURL}${n}`}buildRequestOptions(e,n){let r=this.header.native,s;if(n!==void 0&&e!=="GET"&&e!=="HEAD"&&e!=="OPTIONS"){if(n instanceof FormData)s=n,this.header.clearContentType();else if(typeof n==="string")s=n;else if(n instanceof Blob||n instanceof ArrayBuffer)s=n;else if(s=JSON.stringify(n),!this.header.has("Content-Type"))this.header.setJson()}return{method:e,headers:r,...s!==void 0&&{body:s},signal:this.abortController.signal}}}export{T as Fetcher};
+
+//# debugId=8AF8D142203AB99D64756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["src/Fetcher.ts"],
+  "sourcesContent": [
+    "import { Header } from \"@ooneex/http-header\";\nimport type { MimeType } from \"@ooneex/http-mimes\";\nimport type { ResponseDataType } from \"@ooneex/http-response\";\nimport type { HttpMethodType } from \"@ooneex/types\";\nimport type { IFetcher } from \"./types\";\n\nexport class Fetcher implements IFetcher {\n  private abortController: AbortController;\n  public readonly header: Header = new Header();\n\n  constructor(private baseURL: string) {\n    this.abortController = new AbortController();\n  }\n\n  public setBearerToken(token: string): this {\n    this.header.setBearerToken(token);\n\n    return this;\n  }\n\n  public setBasicToken(token: string): this {\n    this.header.setBasicAuth(token);\n\n    return this;\n  }\n\n  public clearBearerToken(): this {\n    this.header.remove(\"Authorization\");\n\n    return this;\n  }\n\n  public clearBasicToken(): this {\n    this.header.remove(\"Authorization\");\n\n    return this;\n  }\n\n  public setContentType(contentType: MimeType): this {\n    this.header.contentType(contentType);\n\n    return this;\n  }\n\n  public setLang(lang: string): this {\n    this.header.setLang(lang);\n\n    return this;\n  }\n\n  public abort(): this {\n    this.abortController.abort();\n    this.abortController = new AbortController();\n\n    return this;\n  }\n\n  public clone(): Fetcher {\n    return new Fetcher(this.baseURL);\n  }\n\n  public async get<T extends Record<string, unknown> = Record<string, unknown>>(\n    path: string,\n  ): Promise<ResponseDataType<T>> {\n    return this.request<T>(\"GET\", path);\n  }\n\n  public async post<T extends Record<string, unknown> = Record<string, unknown>>(\n    path: string,\n    data?: unknown,\n  ): Promise<ResponseDataType<T>> {\n    return this.request<T>(\"POST\", path, data);\n  }\n\n  public async put<T extends Record<string, unknown> = Record<string, unknown>>(\n    path: string,\n    data?: unknown,\n  ): Promise<ResponseDataType<T>> {\n    return this.request<T>(\"PUT\", path, data);\n  }\n\n  public async patch<T extends Record<string, unknown> = Record<string, unknown>>(\n    path: string,\n    data?: unknown,\n  ): Promise<ResponseDataType<T>> {\n    return this.request<T>(\"PATCH\", path, data);\n  }\n\n  public async delete<T extends Record<string, unknown> = Record<string, unknown>>(\n    path: string,\n  ): Promise<ResponseDataType<T>> {\n    return this.request<T>(\"DELETE\", path);\n  }\n\n  public async head<T extends Record<string, unknown> = Record<string, unknown>>(\n    path: string,\n  ): Promise<ResponseDataType<T>> {\n    return this.request<T>(\"HEAD\", path);\n  }\n\n  public async options<T extends Record<string, unknown> = Record<string, unknown>>(\n    path: string,\n  ): Promise<ResponseDataType<T>> {\n    return this.request<T>(\"OPTIONS\", path);\n  }\n\n  public async request<T extends Record<string, unknown> = Record<string, unknown>>(\n    method: HttpMethodType,\n    path: string,\n    data?: unknown,\n  ): Promise<ResponseDataType<T>> {\n    const fullURL = this.buildURL(path);\n    const requestOptions = this.buildRequestOptions(method, data);\n    const response = await fetch(fullURL, requestOptions);\n\n    try {\n      return await response.json();\n    } catch (error) {\n      throw new Error(error instanceof Error ? error.message : \"Failed to parse JSON response\");\n    }\n  }\n\n  public async upload<T extends Record<string, unknown> = Record<string, unknown>>(\n    path: string,\n    file: File | Blob,\n    name = \"file\",\n  ): Promise<ResponseDataType<T>> {\n    const formData = new FormData();\n    formData.append(name, file);\n\n    // Clear any existing Content-Type to let browser set multipart/form-data boundary\n    const originalContentType = this.header.get(\"Content-Type\");\n    this.header.remove(\"Content-Type\");\n\n    const result = await this.request<T>(\"POST\", path, formData);\n\n    // Restore original Content-Type if it existed\n    if (originalContentType) {\n      this.header.set(\"Content-Type\", originalContentType);\n    }\n\n    return result;\n  }\n\n  private buildURL(url: string): string {\n    if (url.startsWith(\"http://\") || url.startsWith(\"https://\")) {\n      return url;\n    }\n\n    const path = url.startsWith(\"/\") ? url : `/${url}`;\n    const baseURL = this.baseURL.endsWith(\"/\") ? this.baseURL.slice(0, -1) : this.baseURL;\n\n    return `${baseURL}${path}`;\n  }\n\n  private buildRequestOptions(method: string, data?: unknown): RequestInit {\n    const headers = this.header.native;\n\n    let body: BodyInit | undefined;\n\n    if (data !== undefined && method !== \"GET\" && method !== \"HEAD\" && method !== \"OPTIONS\") {\n      if (data instanceof FormData) {\n        body = data;\n        this.header.clearContentType();\n      } else if (typeof data === \"string\") {\n        body = data;\n      } else if (data instanceof Blob || data instanceof ArrayBuffer) {\n        body = data;\n      } else {\n        body = JSON.stringify(data);\n        // Set Content-Type to application/json if not already set\n        if (!this.header.has(\"Content-Type\")) {\n          this.header.setJson();\n        }\n      }\n    }\n\n    const requestOptions: RequestInit = {\n      method,\n      headers,\n      ...(body !== undefined && { body }),\n      signal: this.abortController.signal,\n    };\n\n    return requestOptions;\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "8AF8D142203AB99D64756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@ooneex/fetcher",
+  "description": "",
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "package.json"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "MIT",
+  "scripts": {
+    "test": "bun test tests",
+    "build": "bunup",
+    "lint": "tsgo --noEmit && bunx biome lint",
+    "publish:prod": "bun publish --tolerate-republish --access public",
+    "publish:pack": "bun pm pack --destination ./dist",
+    "publish:dry": "bun publish --dry-run"
+  },
+  "dependencies": {
+    "@ooneex/http-header": "0.0.1"
+  },
+  "devDependencies": {
+    "@ooneex/http-response": "0.0.1",
+    "@ooneex/http-mimes": "0.0.1",
+    "@ooneex/types": "0.0.1"
+  }
+}