@indra211/httpease 1.0.0

package/LICENSE

@@ -0,0 +1,40 @@
+Copyright (c) 2026 INDRA211. All rights reserved.
+
+PROPRIETARY SOFTWARE LICENSE
+
+This software and associated documentation files (the "Software") are the
+exclusive intellectual property of INDRA211 ("the Author").
+
+PERMITTED USES
+--------------
+You are permitted to:
+  - Install and use the Software in your own projects (personal or commercial).
+  - Import or require the Software as a dependency in your applications.
+
+RESTRICTIONS
+------------
+You are NOT permitted to:
+  - Copy, modify, merge, adapt, or create derivative works of the Software.
+  - Redistribute, sublicense, sell, or transfer the Software or any portion
+    of it to any third party.
+  - Submit pull requests, patches, or any form of contribution to this project.
+    All updates, improvements, and maintenance are exclusively reserved for
+    the Author.
+  - Remove or alter this license notice from any copy of the Software.
+
+NO CONTRIBUTIONS
+----------------
+This project does not accept external contributions of any kind. The Author
+is the sole maintainer and retains full control over all changes and releases.
+If you discover a bug or have a feature request, you may open an issue for
+the Author's consideration, but no code contributions will be accepted or
+merged.
+
+DISCLAIMER
+----------
+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
+AUTHOR 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,425 @@
+# 🚀 HTTP Ease
+
+A lightweight, powerful HTTP client for JavaScript & TypeScript — Built on native fetch with automatic retry, interceptors, progress tracking, and more.
+
+[![npm version](https://img.shields.io/npm/v/http-ease.svg)](https://www.npmjs.com/package/http-ease)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## ✨ Why HTTP Ease?
+
+HTTP Ease is a modern HTTP client that combines the simplicity of native `fetch` with the power of Axios, **without any dependencies**.
+
+### Key Features
+
+- 🪶 **Lightweight** - Zero dependencies, ~5KB gzipped
+- 🔄 **Built-in Retry** - Automatic retry with exponential backoff (unlike Axios!)
+- 🎯 **Interceptors** - Request and response interceptors like Axios
+- ⚡ **Modern** - Built on native Fetch API
+- ⏱️ **Timeout Support** - Automatic request cancellation
+- 📦 **Universal** - Works in Node.js 18+ and all modern browsers
+- 🎨 **TypeScript Ready** - Full type definitions included, zero extra setup
+- 📊 **Progress Tracking** - Upload & download progress via native streams
+- 🔧 **Customizable** - Transform requests/responses, custom validators
+
+## 📦 Installation
+
+```bash
+npm install httpease
+```
+
+## 🎯 Quick Start
+
+### JavaScript
+```javascript
+const httpEase = require('httpease');
+
+// Simple GET request
+const response = await httpEase.get('https://api.example.com/users');
+console.log(response.data);
+
+// POST request
+const newUser = await httpEase.post('https://api.example.com/users', {
+  name: 'John Doe',
+  email: 'john@example.com'
+});
+```
+
+### TypeScript
+```typescript
+import httpEase, { create, HttpEaseResponse } from 'httpease';
+
+interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+// Fully typed response
+const response = await httpEase.get<User[]>('https://api.example.com/users');
+const users: User[] = response.data; // ✅ type-safe
+
+// Create a typed instance
+const api = create({ baseURL: 'https://api.example.com' });
+
+const user = await api.get<User>('/users/1');
+console.log(user.data.name); // ✅ IntelliSense works
+```
+
+## 📖 Documentation
+
+### Creating an Instance
+
+```typescript
+import { create } from 'httpease';
+
+const api = create({
+  baseURL: 'https://api.example.com',
+  timeout: 10000,
+  headers: {
+    'Authorization': 'Bearer YOUR_TOKEN',
+    'Content-Type': 'application/json'
+  },
+  retries: 3,
+  retryDelay: 1000
+});
+```
+
+### Making Requests
+
+```typescript
+// GET
+const users = await api.get('/users');
+const user  = await api.get('/users/123');
+
+// GET with query parameters
+const filtered = await api.get('/users', {
+  params: {
+    role: 'admin',
+    active: true
+  }
+});
+
+// POST
+const created = await api.post('/users', {
+  name: 'Jane Doe',
+  email: 'jane@example.com'
+});
+
+// PUT
+const updated = await api.put('/users/123', { name: 'Jane Smith' });
+
+// PATCH
+const patched = await api.patch('/users/123', { email: 'jane.smith@example.com' });
+
+// DELETE
+await api.delete('/users/123');
+
+// HEAD
+const headers = await api.head('/users/123');
+
+// OPTIONS
+const options = await api.options('/users');
+```
+
+### Response Object
+
+```typescript
+{
+  data: {},           // Parsed response data (auto-JSON)
+  status: 200,        // HTTP status code
+  statusText: 'OK',   // HTTP status text
+  headers: {},        // Response headers (plain object)
+  config: {},         // Request configuration used
+  request: {},        // { url, method }
+  duration: 234       // Round-trip time in ms
+}
+```
+
+### TypeScript — Generic Responses
+
+No type assertions needed. Pass the expected type as a generic:
+
+```typescript
+interface Product {
+  id: number;
+  name: string;
+  price: number;
+}
+
+// api.get<T> → Promise<HttpEaseResponse<T>>
+const { data } = await api.get<Product[]>('/products');
+//      ^ Product[]  — fully typed, no casting
+
+const { data: product } = await api.post<Product>('/products', {
+  name: 'Widget',
+  price: 9.99
+});
+```
+
+### 📊 Progress Tracking
+
+Progress tracking works with **zero dependencies** using native `ReadableStream` / `TransformStream` (Node.js 18+, all modern browsers).
+
+**Download Progress:**
+
+```typescript
+const response = await api.get('/files/large-dataset.json', {
+  onDownloadProgress: ({ loaded, total, percentage }) => {
+    if (total > 0) {
+      process.stdout.write(`\rDownloading... ${percentage.toFixed(1)}%`);
+    } else {
+      console.log(`Downloaded ${loaded} bytes`);
+    }
+  }
+});
+console.log('\nDone!', response.data);
+```
+
+**Upload Progress:**
+
+```typescript
+const payload = JSON.stringify({ items: largeArray });
+
+const response = await api.post('/data/import', payload, {
+  onUploadProgress: ({ loaded, total, percentage }) => {
+    console.log(`Uploading: ${percentage.toFixed(1)}% (${loaded}/${total} bytes)`);
+  }
+});
+```
+
+**With FormData (browser):**
+
+```typescript
+const form = new FormData();
+form.append('file', fileInput.files[0]);
+
+await api.post('/upload', form, {
+  onUploadProgress: ({ loaded, total, percentage }) => {
+    progressBar.style.width = `${percentage}%`;
+  }
+});
+```
+
+**Progress Event Object:**
+
+```typescript
+interface ProgressEvent {
+  loaded: number;     // bytes transferred so far
+  total: number;      // total bytes (0 if unknown — no Content-Length)
+  percentage: number; // 0–100, or 0 when total is unknown
+}
+```
+
+> **Note:** Upload progress requires `TransformStream` (Node.js 18+, Chrome 67+, Firefox 102+, Safari 14.1+). The library falls back silently to a non-streaming body in older environments.
+
+### Interceptors
+
+**Request Interceptor:**
+
+```typescript
+api.interceptors.request.use(
+  (config) => {
+    // Modify request before sending
+    config.headers['X-Custom-Header'] = 'value';
+    console.log('Sending request to:', config.url);
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
+  }
+);
+```
+
+**Response Interceptor:**
+
+```typescript
+api.interceptors.response.use(
+  (response) => {
+    console.log('Received:', response.status);
+    return response;
+  },
+  (error) => {
+    if (error.response?.status === 401) {
+      // Redirect to login
+    }
+    return Promise.reject(error);
+  }
+);
+```
+
+**Remove an interceptor:**
+
+```typescript
+const id = api.interceptors.request.use(myHandler);
+api.interceptors.request.eject(id);   // remove one
+api.interceptors.request.clear();     // remove all
+```
+
+### Automatic Retry
+
+**Basic Retry:**
+
+```typescript
+const api = create({
+  baseURL: 'https://api.example.com',
+  retries: 3,              // Retry up to 3 times
+  retryDelay: 1000,        // Start with 1 second delay
+  onRetry: (attempt, delay, error) => {
+    console.log(`Retry ${attempt} after ${delay}ms`);
+  }
+});
+```
+
+**Custom Retry Logic:**
+
+```typescript
+const api = create({
+  retries: 5,
+  retryDelay: (attempt) => {
+    // Custom backoff: 1s, 2s, 4s, 8s, 16s
+    return Math.pow(2, attempt - 1) * 1000;
+  },
+  retryCondition: (error, attempt) => {
+    // Only retry on network errors and 503
+    if (!error.response) return true;
+    return error.response.status === 503;
+  }
+});
+```
+
+**Per-Request Retry:**
+
+```typescript
+// Override retry config for a specific request
+await api.get('/critical-endpoint', {
+  retries: 5,
+  retryDelay: 2000
+});
+```
+
+### Error Handling
+
+```typescript
+import { HttpEaseError } from 'httpease';
+
+try {
+  const response = await api.get('/users/999');
+} catch (error) {
+  if (error.isHttpError) {
+    if (error.response) {
+      // Server responded with error status
+      console.error('Status:', error.response.status);
+      console.error('Data:',   error.response.data);
+    } else if (error.code === 'ETIMEDOUT') {
+      console.error('Request timed out');
+    } else {
+      console.error('Network error:', error.message);
+    }
+  }
+}
+```
+
+### Configuration Options
+
+```typescript
+{
+  // Base URL for all requests
+  baseURL: 'https://api.example.com',
+
+  // Request timeout in milliseconds (default: 30000)
+  timeout: 30000,
+
+  // Custom headers
+  headers: { 'Content-Type': 'application/json' },
+
+  // Number of retry attempts (default: 0)
+  retries: 0,
+
+  // Retry delay — ms number or function
+  retryDelay: 1000,
+  // retryDelay: (attempt) => Math.pow(2, attempt - 1) * 1000,
+
+  // Custom retry condition
+  retryCondition: (error, attempt) => boolean,
+
+  // Callback on retry
+  onRetry: (attempt, delay, error) => void,
+
+  // Query parameters
+  params: {},
+
+  // Request data
+  data: {},
+
+  // Validate status code
+  validateStatus: (status) => status >= 200 && status < 300,
+
+  // Include credentials (CORS)
+  withCredentials: false,
+
+  // Transform request data before sending
+  transformRequest: [(data, headers) => data],
+
+  // Transform response data after receiving
+  transformResponse: [(data) => data],
+
+  // Upload progress callback
+  onUploadProgress: ({ loaded, total, percentage }) => void,
+
+  // Download progress callback
+  onDownloadProgress: ({ loaded, total, percentage }) => void,
+}
+```
+
+## 🆚 Comparison with Axios
+
+| Feature                     | HTTP Ease | Axios                |
+| ----------------------------| --------- | -------------------- |
+| **Size**                    | ~5KB      | ~13KB                |
+| **Dependencies**            | 0         | Many                 |
+| **Built-in Retry**          | ✅ Yes    | ❌ No (needs plugin) |
+| **Interceptors**            | ✅ Yes    | ✅ Yes               |
+| **Timeout**                 | ✅ Yes    | ✅ Yes               |
+| **Auto JSON**               | ✅ Yes    | ✅ Yes               |
+| **Query Params**            | ✅ Yes    | ✅ Yes               |
+| **Progress Tracking**       | ✅ Yes    | ✅ Yes               |
+| **Cancel Requests**         | ✅ Yes    | ✅ Yes               |
+| **TypeScript**              | ✅ Yes    | ✅ Yes               |
+
+## 🎯 Use Cases
+
+Perfect for:
+
+- ✅ Building typed API clients in TypeScript
+- ✅ Making HTTP requests in React/Vue/Angular apps
+- ✅ Node.js backend services
+- ✅ File upload/download with progress UI
+- ✅ Projects where bundle size matters
+- ✅ Apps needing automatic retry logic
+
+## 📝 Examples
+
+Check out the `/examples` directory for:
+
+- `basic.js` - Basic usage examples
+- `interceptors.js` - Request/response interceptors
+- `retry.js` - Retry configuration examples
+- `progress.js` - Upload & download progress examples
+
+## 🚫 Contributing
+
+This project does **not** accept external contributions. Only the author pushes updates and new releases. If you encounter a bug or have a feature idea, you are welcome to open an issue — but pull requests and code patches will not be reviewed or merged.
+
+## 📄 License
+
+Proprietary © 2026 **INDRA211**. All rights reserved.
+
+This software is **not open source**. You may install and use it in your projects, but you may not copy, modify, redistribute, or contribute to it. See the [LICENSE](./LICENSE) file for full terms.
+
+## 🙏 Acknowledgments
+
+Inspired by [Axios](https://github.com/axios/axios) but built for the modern web with native fetch and zero dependencies.
+
+---
+
+**Made with ❤️ by INDRA211**

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@indra211/httpease",
+  "version": "1.0.0",
+  "description": "Lightweight HTTP client built on native fetch — zero dependencies, TypeScript support, retry, interceptors & progress tracking.",
+  "main": "src/index.js",
+  "types": "src/types/index.d.ts",
+  "files": [
+    "src/",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "keywords": [
+    "http",
+    "fetch",
+    "client",
+    "typescript",
+    "retry",
+    "interceptors",
+    "progress",
+    "http-client",
+    "zero-dependency",
+    "upload-progress",
+    "download-progress"
+  ],
+  "author": "INDRA211",
+  "license": "UNLICENSED",
+  "private": false,
+  "type": "commonjs"
+}