@ooneex/http-request-file 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,454 @@
+# @ooneex/http-request-file
+
+A comprehensive TypeScript/JavaScript library for handling HTTP request files with type-safe file operations and MIME type detection. This package provides a robust wrapper around the native File API with additional utilities for file processing, validation, and I/O operations.
+
+![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
+
+✅ **File Wrapper** - Enhanced File API wrapper with additional utilities
+
+✅ **Type-Safe** - Full TypeScript support with proper type definitions
+
+✅ **MIME Type Detection** - Built-in MIME type detection and validation
+
+✅ **Multiple Read Methods** - Support for ArrayBuffer, Stream, and Text reading
+
+✅ **File Properties** - Rich file metadata including size, type, and extension
+
+✅ **Automatic Naming** - Generates unique filenames and normalizes original names
+
+✅ **Cross-Platform** - Works in Browser, Node.js, Bun, and Deno
+
+✅ **File I/O Operations** - Built-in file writing capabilities
+
+✅ **Format Detection** - Automatic detection of images, videos, documents, and more
+
+## Installation
+
+### Bun
+```bash
+bun add @ooneex/http-request-file
+```
+
+### pnpm
+```bash
+pnpm add @ooneex/http-request-file
+```
+
+### Yarn
+```bash
+yarn add @ooneex/http-request-file
+```
+
+### npm
+```bash
+npm install @ooneex/http-request-file
+```
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { RequestFile } from '@ooneex/http-request-file';
+
+// Create from a native File object (e.g., from form upload)
+const nativeFile = new File(['Hello, world!'], 'example.txt', { type: 'text/plain' });
+const requestFile = new RequestFile(nativeFile);
+
+// Access file properties
+console.log(requestFile.id); // Unique 25-character ID
+console.log(requestFile.name); // Generated name: "abc123def456ghi789jkl012.txt"
+console.log(requestFile.originalName); // Normalized: "example.txt"
+console.log(requestFile.type); // "text/plain"
+console.log(requestFile.size); // File size in bytes
+console.log(requestFile.extension); // "txt"
+
+// Check file types
+console.log(requestFile.isText); // true
+console.log(requestFile.isImage); // false
+console.log(requestFile.isPdf); // false
+```
+
+### File Reading Operations
+
+```typescript
+import { RequestFile } from '@ooneex/http-request-file';
+
+const imageFile = new File([/* binary data */], 'photo.jpg', { type: 'image/jpeg' });
+const requestFile = new RequestFile(imageFile);
+
+// Read as text (for text files)
+const textContent = await requestFile.readAsText();
+console.log(textContent);
+
+// Read as ArrayBuffer (for binary files)
+const buffer = await requestFile.readAsArrayBuffer();
+console.log(new Uint8Array(buffer));
+
+// Read as stream (for large files)
+const stream = requestFile.readAsStream();
+const reader = stream.getReader();
+const { value, done } = await reader.read();
+```
+
+### File Type Detection
+
+```typescript
+import { RequestFile } from '@ooneex/http-request-file';
+
+// Image file
+const imageFile = new File([/* data */], 'photo.png', { type: 'image/png' });
+const imageRequest = new RequestFile(imageFile);
+console.log(imageRequest.isImage); // true
+console.log(imageRequest.isSvg); // false
+
+// Document file
+const pdfFile = new File([/* data */], 'document.pdf', { type: 'application/pdf' });
+const pdfRequest = new RequestFile(pdfFile);
+console.log(pdfRequest.isPdf); // true
+console.log(pdfRequest.isText); // false
+
+// Excel file
+const excelFile = new File([/* data */], 'spreadsheet.xlsx', {
+  type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+});
+const excelRequest = new RequestFile(excelFile);
+console.log(excelRequest.isExcel); // true
+```
+
+### File Writing
+
+```typescript
+import { RequestFile } from '@ooneex/http-request-file';
+
+const file = new File(['File content'], 'example.txt', { type: 'text/plain' });
+const requestFile = new RequestFile(file);
+
+// Write file to disk (Bun/Node.js)
+await requestFile.write('./uploads/saved-file.txt');
+```
+
+### Advanced Usage
+
+```typescript
+import { RequestFile } from '@ooneex/http-request-file';
+
+// Handle form upload
+function handleFileUpload(files: FileList) {
+  Array.from(files).forEach(file => {
+    const requestFile = new RequestFile(file);
+
+    console.log(`Processing: ${requestFile.originalName}`);
+    console.log(`Size: ${requestFile.size} bytes`);
+    console.log(`Type: ${requestFile.type}`);
+
+    // Process based on file type
+    if (requestFile.isImage) {
+      console.log('Processing image file');
+      // Handle image processing
+    } else if (requestFile.isPdf) {
+      console.log('Processing PDF document');
+      // Handle PDF processing
+    } else if (requestFile.isExcel || requestFile.isCsv) {
+      console.log('Processing spreadsheet');
+      // Handle spreadsheet processing
+    }
+  });
+}
+
+// Batch processing with concurrent operations
+async function processBatch(files: File[]) {
+  const requestFiles = files.map(file => new RequestFile(file));
+
+  // Process text files
+  const textFiles = requestFiles.filter(rf => rf.isText);
+  const textContents = await Promise.all(
+    textFiles.map(rf => rf.readAsText())
+  );
+
+  // Process image files
+  const imageFiles = requestFiles.filter(rf => rf.isImage);
+  const imageBuffers = await Promise.all(
+    imageFiles.map(rf => rf.readAsArrayBuffer())
+  );
+
+  return { textContents, imageBuffers };
+}
+```
+
+## API Reference
+
+### `RequestFile` Class
+
+The main class for wrapping native File objects with enhanced functionality.
+
+#### Constructor
+
+```typescript
+constructor(native: File)
+```
+
+Creates a new RequestFile instance from a native File object.
+
+**Parameters:**
+- `native` - The native File object to wrap
+
+#### Properties
+
+##### `id: string` (readonly)
+Unique 25-character identifier for the file.
+
+##### `name: string` (readonly)
+Generated filename using the unique ID and original extension.
+**Format:** `{id}.{extension}`
+
+##### `originalName: string` (readonly)
+Original filename converted to kebab-case with extension preserved.
+
+##### `type: MimeType` (readonly)
+MIME type of the file (charset parameters removed).
+
+##### `size: number` (readonly)
+File size in bytes.
+
+##### `extension: string` (readonly)
+File extension in lowercase.
+
+##### File Type Detection Properties
+
+All properties return `boolean` values:
+
+- `isImage` - Detects image files (PNG, JPEG, GIF, WebP, etc.)
+- `isSvg` - Detects SVG images specifically
+- `isVideo` - Detects video files (MP4, WebM, AVI, etc.)
+- `isAudio` - Detects audio files (MP3, WAV, OGG, etc.)
+- `isPdf` - Detects PDF documents
+- `isText` - Detects text-based files
+- `isExcel` - Detects Excel/spreadsheet files
+- `isCsv` - Detects CSV files
+- `isJson` - Detects JSON files
+- `isXml` - Detects XML files
+- `isHtml` - Detects HTML files
+
+#### Methods
+
+##### `readAsArrayBuffer(): Promise<ArrayBuffer>`
+Reads the file content as an ArrayBuffer.
+
+**Returns:** Promise that resolves to an ArrayBuffer containing the file data.
+
+**Example:**
+```typescript
+const buffer = await requestFile.readAsArrayBuffer();
+const uint8Array = new Uint8Array(buffer);
+```
+
+##### `readAsStream(): ReadableStream<Uint8Array>`
+Returns a readable stream of the file content.
+
+**Returns:** ReadableStream for streaming file data.
+
+**Example:**
+```typescript
+const stream = requestFile.readAsStream();
+const reader = stream.getReader();
+
+while (true) {
+  const { done, value } = await reader.read();
+  if (done) break;
+  console.log('Chunk:', value);
+}
+```
+
+##### `readAsText(): Promise<string>`
+Reads the file content as a text string.
+
+**Returns:** Promise that resolves to the file content as a string.
+
+**Example:**
+```typescript
+const text = await requestFile.readAsText();
+console.log(text);
+```
+
+##### `write(path: string): Promise<void>`
+Writes the file to the specified path on disk.
+
+**Parameters:**
+- `path` - The file system path where to write the file
+
+**Returns:** Promise that resolves when the file is written.
+
+**Example:**
+```typescript
+await requestFile.write('./uploads/my-file.txt');
+```
+
+### Interface
+
+#### `IRequestFile`
+Interface defining all available properties and methods for request files.
+
+```typescript
+interface IRequestFile {
+  readonly id: string;
+  readonly name: string;
+  readonly originalName: string;
+  readonly type: MimeType;
+  readonly size: number;
+  readonly extension: string;
+  readonly isImage: boolean;
+  readonly isVideo: boolean;
+  readonly isAudio: boolean;
+  readonly isPdf: boolean;
+  readonly isText: boolean;
+  readonly isExcel: boolean;
+  readonly isCsv: boolean;
+  readonly isJson: boolean;
+  readonly isXml: boolean;
+  readonly isHtml: boolean;
+  readonly isSvg: boolean;
+  readAsArrayBuffer(): Promise<ArrayBuffer>;
+  readAsStream(): ReadableStream<Uint8Array>;
+  readAsText(): Promise<string>;
+  write(path: string): Promise<void>;
+}
+```
+
+## Use Cases
+
+### File Upload Handler
+
+```typescript
+import { RequestFile } from '@ooneex/http-request-file';
+
+async function handleUpload(formData: FormData) {
+  const file = formData.get('file') as File;
+  if (!file) return;
+
+  const requestFile = new RequestFile(file);
+
+  // Validate file type
+  if (!requestFile.isImage && !requestFile.isPdf) {
+    throw new Error('Only images and PDFs are allowed');
+  }
+
+  // Generate safe filename
+  const safePath = `./uploads/${requestFile.name}`;
+
+  // Save to disk
+  await requestFile.write(safePath);
+
+  return {
+    id: requestFile.id,
+    originalName: requestFile.originalName,
+    size: requestFile.size,
+    type: requestFile.type,
+    saved: safePath
+  };
+}
+```
+
+### Image Processing Pipeline
+
+```typescript
+import { RequestFile } from '@ooneex/http-request-file';
+
+async function processImageBatch(files: File[]) {
+  const results = [];
+
+  for (const file of files) {
+    const requestFile = new RequestFile(file);
+
+    if (requestFile.isImage && !requestFile.isSvg) {
+      // Process raster images
+      const buffer = await requestFile.readAsArrayBuffer();
+      // ... process with image library
+
+      results.push({
+        id: requestFile.id,
+        type: 'raster',
+        processed: true
+      });
+    } else if (requestFile.isSvg) {
+      // Process SVG images
+      const svg = await requestFile.readAsText();
+      // ... process SVG content
+
+      results.push({
+        id: requestFile.id,
+        type: 'svg',
+        processed: true
+      });
+    }
+  }
+
+  return results;
+}
+```
+
+### Document Analysis
+
+```typescript
+import { RequestFile } from '@ooneex/http-request-file';
+
+async function analyzeDocuments(files: File[]) {
+  const analysis = {
+    documents: 0,
+    spreadsheets: 0,
+    images: 0,
+    other: 0,
+    totalSize: 0
+  };
+
+  for (const file of files) {
+    const requestFile = new RequestFile(file);
+    analysis.totalSize += requestFile.size;
+
+    if (requestFile.isPdf) {
+      analysis.documents++;
+    } else if (requestFile.isExcel || requestFile.isCsv) {
+      analysis.spreadsheets++;
+    } else if (requestFile.isImage) {
+      analysis.images++;
+    } else {
+      analysis.other++;
+    }
+  }
+
+  return analysis;
+}
+```
+
+## 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,51 @@
+import { MimeType as MimeType2 } from "@ooneex/http-mimes";
+import { MimeType } from "@ooneex/http-mimes";
+interface IRequestFile {
+	readonly id: string;
+	readonly name: string;
+	readonly originalName: string;
+	readonly type: MimeType;
+	readonly size: number;
+	readonly extension: string;
+	readonly isImage: boolean;
+	readonly isVideo: boolean;
+	readonly isAudio: boolean;
+	readonly isPdf: boolean;
+	readonly isText: boolean;
+	readonly isExcel: boolean;
+	readonly isCsv: boolean;
+	readonly isJson: boolean;
+	readonly isXml: boolean;
+	readonly isHtml: boolean;
+	readonly isSvg: boolean;
+	readAsArrayBuffer: () => Promise<ArrayBuffer>;
+	readAsStream: () => ReadableStream<Uint8Array>;
+	readAsText: () => Promise<string>;
+	write: (path: string) => Promise<void>;
+}
+declare class RequestFile implements IRequestFile {
+	private readonly native;
+	readonly id: string;
+	readonly name: string;
+	readonly originalName: string;
+	readonly type: MimeType2;
+	readonly size: number;
+	readonly extension: string;
+	readonly isImage: boolean;
+	readonly isSvg: boolean;
+	readonly isVideo: boolean;
+	readonly isAudio: boolean;
+	readonly isPdf: boolean;
+	readonly isText: boolean;
+	readonly isExcel: boolean;
+	readonly isCsv: boolean;
+	readonly isJson: boolean;
+	readonly isXml: boolean;
+	readonly isHtml: boolean;
+	constructor(native: File);
+	readAsArrayBuffer(): Promise<ArrayBuffer>;
+	readAsStream(): ReadableStream<Uint8Array>;
+	readAsText(): Promise<string>;
+	write(path: string): Promise<void>;
+}
+export { RequestFile, IRequestFile };

package/dist/index.js

@@ -0,0 +1,3 @@
+import{Mime as a}from"@ooneex/http-mimes";import{random as n,toKebabCase as t}from"@ooneex/utils";class r{native;id;name;originalName;type;size;extension;isImage;isSvg;isVideo;isAudio;isPdf;isText;isExcel;isCsv;isJson;isXml;isHtml;constructor(s){this.native=s;let o=this.native.name.match(/\.([0-9a-z]+)$/i);this.extension=(o?o[1]:"")?.toLowerCase()||"",this.originalName=t(this.native.name.replace(/\.[0-9a-z]*$/i,"")),this.originalName=`${this.originalName}.${this.extension}`,this.type=this.native.type.replace(/\s*;.*$/,""),this.size=this.native.size,this.id=n.nanoid(25),this.name=`${this.id}.${this.extension}`;let e=new a,i=this.type;this.isImage=e.isImage(i),this.isSvg=e.isSvg(i),this.isVideo=e.isVideo(i),this.isAudio=e.isAudio(i),this.isPdf=e.isPdf(i),this.isText=e.isText(i),this.isExcel=e.isExcel(i),this.isCsv=e.isCsv(i),this.isJson=e.isJson(i),this.isXml=e.isXml(i),this.isHtml=e.isHtml(i)}async readAsArrayBuffer(){return await this.native.arrayBuffer()}readAsStream(){return this.native.stream()}async readAsText(){return await this.native.text()}async write(s){await Bun.write(s,this.native)}}export{r as RequestFile};
+
+//# debugId=ED70B1F359AF8DC664756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["src/RequestFile.ts"],
+  "sourcesContent": [
+    "import { Mime, type MimeType } from \"@ooneex/http-mimes\";\nimport { random, toKebabCase } from \"@ooneex/utils\";\nimport type { IRequestFile } from \"./types\";\n\nexport class RequestFile implements IRequestFile {\n  public readonly id: string;\n  public readonly name: string;\n  public readonly originalName: string;\n  public readonly type: MimeType;\n  public readonly size: number;\n  public readonly extension: string;\n  public readonly isImage: boolean;\n  public readonly isSvg: boolean;\n  public readonly isVideo: boolean;\n  public readonly isAudio: boolean;\n  public readonly isPdf: boolean;\n  public readonly isText: boolean;\n  public readonly isExcel: boolean;\n  public readonly isCsv: boolean;\n  public readonly isJson: boolean;\n  public readonly isXml: boolean;\n  public readonly isHtml: boolean;\n\n  constructor(private readonly native: File) {\n    const match = this.native.name.match(/\\.([0-9a-z]+)$/i);\n    this.extension = (match ? match[1] : \"\")?.toLowerCase() || \"\";\n    this.originalName = toKebabCase(this.native.name.replace(/\\.[0-9a-z]*$/i, \"\"));\n    this.originalName = `${this.originalName}.${this.extension}`;\n    this.type = this.native.type.replace(/\\s*;.*$/, \"\") as MimeType;\n    this.size = this.native.size;\n    this.id = random.nanoid(25);\n    this.name = `${this.id}.${this.extension}`;\n\n    const mime = new Mime();\n    const typeAsString = this.type as string;\n\n    this.isImage = mime.isImage(typeAsString);\n    this.isSvg = mime.isSvg(typeAsString);\n    this.isVideo = mime.isVideo(typeAsString);\n    this.isAudio = mime.isAudio(typeAsString);\n    this.isPdf = mime.isPdf(typeAsString);\n    this.isText = mime.isText(typeAsString);\n    this.isExcel = mime.isExcel(typeAsString);\n    this.isCsv = mime.isCsv(typeAsString);\n    this.isJson = mime.isJson(typeAsString);\n    this.isXml = mime.isXml(typeAsString);\n    this.isHtml = mime.isHtml(typeAsString);\n  }\n\n  public async readAsArrayBuffer(): Promise<ArrayBuffer> {\n    return await this.native.arrayBuffer();\n  }\n\n  public readAsStream(): ReadableStream<Uint8Array> {\n    return this.native.stream();\n  }\n\n  public async readAsText(): Promise<string> {\n    return await this.native.text();\n  }\n\n  public async write(path: string): Promise<void> {\n    await Bun.write(path, this.native);\n  }\n}\n"
+  ],
+  "mappings": "AAAA,eAAS,2BACT,iBAAS,iBAAQ,sBAGV,MAAM,CAAoC,CAmBlB,OAlBb,GACA,KACA,aACA,KACA,KACA,UACA,QACA,MACA,QACA,QACA,MACA,OACA,QACA,MACA,OACA,MACA,OAEhB,WAAW,CAAkB,EAAc,CAAd,cAC3B,IAAM,EAAQ,KAAK,OAAO,KAAK,MAAM,iBAAiB,EACtD,KAAK,WAAa,EAAQ,EAAM,GAAK,KAAK,YAAY,GAAK,GAC3D,KAAK,aAAe,EAAY,KAAK,OAAO,KAAK,QAAQ,gBAAiB,EAAE,CAAC,EAC7E,KAAK,aAAe,GAAG,KAAK,gBAAgB,KAAK,YACjD,KAAK,KAAO,KAAK,OAAO,KAAK,QAAQ,UAAW,EAAE,EAClD,KAAK,KAAO,KAAK,OAAO,KACxB,KAAK,GAAK,EAAO,OAAO,EAAE,EAC1B,KAAK,KAAO,GAAG,KAAK,MAAM,KAAK,YAE/B,IAAM,EAAO,IAAI,EACX,EAAe,KAAK,KAE1B,KAAK,QAAU,EAAK,QAAQ,CAAY,EACxC,KAAK,MAAQ,EAAK,MAAM,CAAY,EACpC,KAAK,QAAU,EAAK,QAAQ,CAAY,EACxC,KAAK,QAAU,EAAK,QAAQ,CAAY,EACxC,KAAK,MAAQ,EAAK,MAAM,CAAY,EACpC,KAAK,OAAS,EAAK,OAAO,CAAY,EACtC,KAAK,QAAU,EAAK,QAAQ,CAAY,EACxC,KAAK,MAAQ,EAAK,MAAM,CAAY,EACpC,KAAK,OAAS,EAAK,OAAO,CAAY,EACtC,KAAK,MAAQ,EAAK,MAAM,CAAY,EACpC,KAAK,OAAS,EAAK,OAAO,CAAY,OAG3B,kBAAiB,EAAyB,CACrD,OAAO,MAAM,KAAK,OAAO,YAAY,EAGhC,YAAY,EAA+B,CAChD,OAAO,KAAK,OAAO,OAAO,OAGf,WAAU,EAAoB,CACzC,OAAO,MAAM,KAAK,OAAO,KAAK,OAGnB,MAAK,CAAC,EAA6B,CAC9C,MAAM,IAAI,MAAM,EAAM,KAAK,MAAM,EAErC",
+  "debugId": "ED70B1F359AF8DC664756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@ooneex/http-request-file",
+  "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-mimes": "0.0.1",
+    "@ooneex/utils": "0.0.8"
+  },
+  "devDependencies": {}
+}