@visulima/storage 1.0.0-alpha.1 → 1.0.0-alpha.3

package/CHANGELOG.md

@@ -1,3 +1,33 @@
+## @visulima/storage [1.0.0-alpha.3](https://github.com/visulima/visulima/compare/@visulima/storage@1.0.0-alpha.2...@visulima/storage@1.0.0-alpha.3) (2025-12-10)
+
+
+### Dependencies
+
+* **@visulima/humanizer:** upgraded to 3.0.0-alpha.3
+
+## @visulima/storage [1.0.0-alpha.2](https://github.com/visulima/visulima/compare/@visulima/storage@1.0.0-alpha.1...@visulima/storage@1.0.0-alpha.2) (2025-12-07)
+
+### ⚠ BREAKING CHANGES
+
+* change min node version to 22.13
+
+### Bug Fixes
+
+* add new package image, fixed readme rendering on npm, fixed building of packages ([b790ba2](https://github.com/visulima/visulima/commit/b790ba253ea07fef83528fd822a678facf021b5f))
+* update Node.js engine version requirement to >=22.13 in multiple package.json files for improved compatibility ([b828e9a](https://github.com/visulima/visulima/commit/b828e9aeaebfc798eecddccd90e6ec7560c6d36a))
+
+### Miscellaneous Chores
+
+* moved all packages into groups ([0615e9d](https://github.com/visulima/visulima/commit/0615e9d14a8a886e11da529ce150cf31ca973c10))
+* update @anolilab/semantic-release-pnpm and @anolilab/semantic-release-preset to versions 3.2.2 and 12.1.2 across multiple package.json files for improved compatibility ([3921626](https://github.com/visulima/visulima/commit/3921626141fe5da398749bf0ba675f1596f18afb))
+* update dependencies across multiple packages to improve compatibility and performance, including upgrading `@anolilab/semantic-release-pnpm` and `@anolilab/semantic-release-preset` to versions 3.2.0 and 12.1.0 respectively, and updating `react`, `react-dom`, and `next` versions to 19.2.1 and 16.0.7 in various package.json files ([aee8fcd](https://github.com/visulima/visulima/commit/aee8fcd796ae9b8d055903260e7150996ea9f53d))
+* update implicit dependencies in project.json for storage package ([2473f8a](https://github.com/visulima/visulima/commit/2473f8a2297df40425ba4eb4d9eb14d40db0b6ac))
+
+
+### Dependencies
+
+* **@visulima/fs:** upgraded to 5.0.0-alpha.1
+
 ## @visulima/storage 1.0.0-alpha.1 (2025-12-02)
 
 ### Features

package/README.md

@@ -1,15 +1,24 @@
-<div align="center">
-  <h3>Visulima upload</h3>
-  <p>Visulima upload copies files to a web-accessible location and provides a consistent way to get the URLs that correspond to those files.</p>
-  <p>Visulima upload can also resize, crop and autorotate uploaded images.</p>
-  <p>Visulima upload includes S3-based, Azure-based, GCS-based and local filesystem-based backends and you may supply others.</p>
-</div>
+<!-- START_PACKAGE_OG_IMAGE_PLACEHOLDER -->
+
+<a href="https://www.anolilab.com/open-source" align="center">
+
+  <img src="__assets__/package-og.svg" alt="storage" />
+
+</a>
+
+<h3 align="center">Visulima upload - Store files in a web-accessible location via a simplified API. Can automatically scale and rotate images. Includes S3, Azure, GCS and local filesystem-based backends with the most convenient features of each.</h3>
+
+<!-- END_PACKAGE_OG_IMAGE_PLACEHOLDER -->
 
 <br />
 
 <div align="center">
 
-[![typescript-image]][typescript-url] [![npm-image]][npm-url] [![license-image]][license-url]
+[![typescript-image][typescript-badge]][typescript-url]
+[![mit licence][license-badge]][license]
+[![npm downloads][npm-downloads-badge]][npm-downloads]
+[![Chat][chat-badge]][chat]
+[![PRs Welcome][prs-welcome-badge]][prs-welcome]
 
 </div>
 
@@ -549,13 +558,23 @@ If you would like to help take a look at the [list of issues](https://github.com
 - [Daniel Bannert](https://github.com/prisis)
 - [All Contributors](https://github.com/visulima/visulima/graphs/contributors)
 
+## Made with ❤️ at Anolilab
+
+This is an open source project and will always remain free to use. If you think it's cool, please star it 🌟. [Anolilab](https://www.anolilab.com/open-source) is a Development and AI Studio. Contact us at [hello@anolilab.com](mailto:hello@anolilab.com) if you need any help with these technologies or just want to say hi!
+
 ## License
 
-The visulima uploads is open-sourced software licensed under the [MIT][license-url]
+The visulima uploads is open-sourced software licensed under the [MIT][license]
+
+<!-- badges -->
 
-[typescript-image]: https://img.shields.io/badge/Typescript-294E80.svg?style=for-the-badge&logo=typescript
-[typescript-url]: "typescript"
-[license-image]: https://img.shields.io/npm/l/@visulima/upload?color=blueviolet&style=for-the-badge
-[license-url]: LICENSE.md "license"
-[npm-image]: https://img.shields.io/npm/v/@visulima/upload/latest.svg?style=for-the-badge&logo=npm
-[npm-url]: https://www.npmjs.com/package/@visulima/upload/v/latest "npm"
+[license-badge]: https://img.shields.io/npm/l/@visulima/upload?style=for-the-badge
+[license]: https://github.com/visulima/visulima/blob/main/LICENSE
+[npm-downloads-badge]: https://img.shields.io/npm/dm/@visulima/upload?style=for-the-badge
+[npm-downloads]: https://www.npmjs.com/package/@visulima/upload
+[prs-welcome-badge]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=for-the-badge
+[prs-welcome]: https://github.com/visulima/visulima/blob/main/.github/CONTRIBUTING.md
+[chat-badge]: https://img.shields.io/discord/932323359193186354.svg?style=for-the-badge
+[chat]: https://discord.gg/TtFJY8xkFK
+[typescript-badge]: https://img.shields.io/badge/Typescript-294E80.svg?style=for-the-badge&logo=typescript
+[typescript-url]: https://www.typescriptlang.org/

package/dist/adapter/nuxt/module.d.ts

@@ -0,0 +1,39 @@
+import type { UploadOptions } from "../../handler/types.d.ts";
+import type { BaseStorage } from "../../storage/storage.d.ts";
+import type { UploadFile } from "../../storage/utils/index.d.ts";
+/**
+ * CORS configuration for upload endpoints
+ */
+export interface CorsOptions {
+    /** Allowed CORS headers */
+    headers?: string[];
+    /** Allowed HTTP methods */
+    methods?: string[];
+    /** Allowed origins (use "*" for all origins) */
+    origin?: string | string[];
+}
+/**
+ * Configuration options for the Nuxt storage module
+ */
+export interface ModuleOptions {
+    /** Base path for upload routes (default: '/api/upload') */
+    basePath?: string;
+    /** CORS configuration */
+    cors?: CorsOptions;
+    /** Enable multipart upload endpoint (default: true) */
+    multipart?: boolean;
+    /** Additional options for multipart handler */
+    multipartOptions?: Omit<UploadOptions<UploadFile>, "storage">;
+    /** Enable REST API endpoint for direct binary uploads (default: true) */
+    rest?: boolean;
+    /** Additional options for REST handler */
+    restOptions?: Omit<UploadOptions<UploadFile>, "storage">;
+    /** Storage instance to use for file uploads */
+    storage: BaseStorage;
+    /** Enable TUS resumable upload endpoint (default: true) */
+    tus?: boolean;
+    /** Additional options for TUS handler */
+    tusOptions?: Omit<UploadOptions<UploadFile>, "storage">;
+}
+declare const nuxtModule: any;
+export default nuxtModule;

package/dist/adapter/nuxt/module.js

@@ -0,0 +1,93 @@
+import { defineNuxtModule } from '@nuxt/kit';
+
+const handlerStorage = /* @__PURE__ */ new Map();
+const nuxtModule = defineNuxtModule({
+  defaults: {
+    basePath: "/api/upload",
+    cors: {
+      headers: ["Content-Type", "Upload-Offset", "Upload-Length", "Tus-Resumable"],
+      methods: ["GET", "POST", "PATCH", "PUT", "HEAD", "DELETE", "OPTIONS"],
+      origin: "*"
+    },
+    multipart: true,
+    rest: true,
+    tus: true
+  },
+  meta: {
+    compatibility: {
+      nuxt: ">=4.0.0"
+    },
+    configKey: "storage",
+    name: "@visulima/storage"
+  },
+  async setup(options, nuxt) {
+    const {
+      basePath = "/api/upload",
+      cors = {
+        headers: ["Content-Type", "Upload-Offset", "Upload-Length", "Tus-Resumable"],
+        methods: ["GET", "POST", "PATCH", "PUT", "HEAD", "DELETE", "OPTIONS"],
+        origin: "*"
+      },
+      multipart = true,
+      multipartOptions = {},
+      rest = true,
+      restOptions = {},
+      storage,
+      tus = true,
+      tusOptions = {}
+    } = options;
+    if (!storage) {
+      throw new Error("[@visulima/storage/nuxt] Storage instance is required");
+    }
+    const { Multipart, Rest, Tus } = await import('../../handler/http/node/index.js');
+    const multipartHandler = multipart ? new Multipart({ storage, ...multipartOptions }) : void 0;
+    const restHandler = rest ? new Rest({ storage, ...restOptions }) : void 0;
+    const tusHandler = tus ? new Tus({ storage, ...tusOptions }) : void 0;
+    const setCorsHeaders = (event) => {
+      const origin = Array.isArray(cors.origin) ? cors.origin.join(", ") : cors.origin || "*";
+      event.node.res.setHeader("Access-Control-Allow-Origin", origin);
+      if (cors.methods) {
+        event.node.res.setHeader("Access-Control-Allow-Methods", cors.methods.join(", "));
+      }
+      if (cors.headers) {
+        event.node.res.setHeader("Access-Control-Allow-Headers", cors.headers.join(", "));
+      }
+    };
+    if (multipartHandler) {
+      handlerStorage.set(`${basePath}/multipart`, { handler: multipartHandler, setCorsHeaders });
+    }
+    if (restHandler) {
+      handlerStorage.set(`${basePath}/rest`, { handler: restHandler, setCorsHeaders });
+    }
+    if (tusHandler) {
+      handlerStorage.set(`${basePath}/tus`, { handler: tusHandler, setCorsHeaders });
+    }
+    nuxt.hook("nitro:config", (nitroConfig) => {
+      const routeRules = nitroConfig.routeRules || {};
+      if (multipartHandler) {
+        routeRules[`${basePath}/multipart/**`] = { cors: true };
+      }
+      if (restHandler) {
+        routeRules[`${basePath}/rest/**`] = { cors: true };
+      }
+      if (tusHandler) {
+        routeRules[`${basePath}/tus/**`] = { cors: true };
+      }
+      nitroConfig.routeRules = routeRules;
+    });
+    nuxt.hook("nitro:init", (nitro) => {
+      nitro.hooks.hook("request", async (event) => {
+        const url = event.node.req.url || "";
+        for (const [route, { handler, setCorsHeaders: setHeaders }] of handlerStorage.entries()) {
+          if (url.startsWith(route)) {
+            setHeaders(event);
+            await handler.handle(event.node.req, event.node.res);
+            return;
+          }
+        }
+      });
+    });
+  }
+});
+
+export { nuxtModule as default };

package/dist/adapter/nuxt/package.json

@@ -0,0 +1,20 @@
+{
+    "name": "@visulima/storage-nuxt",
+    "version": "0.0.0",
+    "type": "module",
+    "exports": {
+        ".": {
+            "types": "./module.d.ts",
+            "import": "./module.js"
+        }
+    },
+    "main": "./module.js",
+    "types": "./module.d.ts",
+    "files": [
+        "."
+    ],
+    "peerDependencies": {
+        "@nuxt/kit": ">=4.0.0",
+        "nuxt": ">=4.0.0"
+    }
+}

package/dist/handler/base/base-handler-core.d.ts

@@ -0,0 +1,91 @@
+import { EventEmitter } from "node:events";
+import type { BaseStorage } from "../../storage/storage.d.ts";
+import type { UploadFile } from "../../storage/utils/index.d.ts";
+import type MediaTransformer from "../../transformer/media-transformer.d.ts";
+import type { ErrorResponses } from "../../utils/errors.d.ts";
+import type { ResponseBodyType } from "../../utils/types.d.ts";
+import type { UploadOptions } from "../types.d.ts";
+/**
+ * Core base class containing shared business logic for all handlers.
+ * This class is platform-agnostic and contains no Node.js or Web API specific code.
+ * @template TFile The file type used by this handler.
+ */
+declare abstract class BaseHandlerCore<TFile extends UploadFile> extends EventEmitter {
+    /**
+     * Response body type for the handler.
+     */
+    responseType: ResponseBodyType;
+    /**
+     * Storage instance for file operations.
+     */
+    storage: BaseStorage<TFile>;
+    /**
+     * Optional media transformer for image/video processing.
+     */
+    mediaTransformer?: MediaTransformer;
+    /**
+     * Whether to disable termination for finished uploads.
+     */
+    disableTerminationForFinishedUploads?: boolean;
+    /**
+     * Logger instance for debugging and error reporting.
+     */
+    protected logger?: Console;
+    /**
+     * Gets the logger instance.
+     * @returns Logger instance or undefined.
+     */
+    get loggerInstance(): Console | undefined;
+    /**
+     * Internal error responses configuration.
+     */
+    protected internalErrorResponses: ErrorResponses;
+    /**
+     * Gets the error responses configuration.
+     * @returns Error responses configuration.
+     */
+    get errorResponses(): ErrorResponses;
+    constructor({ disableTerminationForFinishedUploads, mediaTransformer, storage }: UploadOptions<TFile>);
+    /**
+     * Sets custom error responses.
+     * @param value Partial error responses to override defaults.
+     */
+    set errorResponses(value: Partial<ErrorResponses>);
+    /**
+     * Assemble error responses by merging defaults with custom overrides.
+     * @param customErrors Custom error responses to override defaults
+     */
+    assembleErrors: (customErrors?: {}) => void;
+    /**
+     * Parses HTTP Range header and returns start/end byte positions for partial content requests.
+     * @param rangeHeader HTTP Range header value (e.g., "bytes=0-1023").
+     * @param fileSize Total size of the file in bytes.
+     * @returns Object with start and end positions, or undefined if range is invalid.
+     */
+    parseRangeHeader(rangeHeader: string | undefined, fileSize: number): {
+        end: number;
+        start: number;
+    } | undefined;
+    /**
+     * Build file URL from request and file data.
+     * Platform-agnostic version that accepts URL string.
+     * @param requestUrl Request URL string
+     * @param file File object containing ID and content type
+     * @returns Constructed file URL with extension based on content type
+     */
+    protected buildFileUrlFromString(requestUrl: string, file: TFile): string;
+    /**
+     * Negotiates content type based on Accept header and supported formats.
+     * Platform-agnostic version that accepts header string.
+     * @param acceptHeader Accept header value
+     * @param supportedTypes Array of supported MIME types to match against
+     * @returns Best matching content type or undefined if no match found
+     */
+    negotiateContentTypeFromHeader(acceptHeader: string | undefined, supportedTypes: string[]): string | undefined;
+    /**
+     * Check for undefined ID or path errors and throw appropriate HTTP errors.
+     * @param error The error to check
+     */
+    protected checkForUndefinedIdOrPath(error: unknown): void;
+}
+export default BaseHandlerCore;

package/dist/handler/base/base-handler-fetch.d.ts

@@ -0,0 +1,76 @@
+import type { UploadFile } from "../../storage/utils/index.d.ts";
+import type { UploadResponse } from "../../utils/types.d.ts";
+import type { Handlers, ResponseFile, ResponseList, UploadOptions } from "../types.d.ts";
+import BaseHandlerCore from "./base-handler-core.d.ts";
+/**
+ * Base handler for Web API Fetch platform (Request/Response).
+ * Extends BaseHandlerCore with Fetch-specific request/response handling.
+ * @template TFile The file type used by this handler.
+ */
+declare abstract class BaseHandlerFetch<TFile extends UploadFile> extends BaseHandlerCore<TFile> {
+    /**
+     * Limiting enabled HTTP method handler.
+     */
+    static readonly methods: Handlers[];
+    /**
+     * Map of registered HTTP method handlers.
+     */
+    protected registeredHandlers: Map<string, (request: Request) => Promise<ResponseFile<TFile> | ResponseList<TFile>>>;
+    constructor(options: UploadOptions<TFile>);
+    /**
+     * Gets the registered handlers map.
+     * @returns Map of registered handlers.
+     */
+    get handlers(): Map<string, (request: Request) => Promise<ResponseFile<TFile> | ResponseList<TFile>>>;
+    /**
+     * Handles Web API Fetch requests (for Hono, Cloudflare Workers, etc.).
+     * @param request Web API Request object.
+     * @returns Promise resolving to Web API Response.
+     */
+    fetch(request: Request): Promise<globalThis.Response>;
+    /**
+     * Compose and register HTTP method handlers.
+     * Subclasses should override this to register their specific handlers.
+     */
+    protected abstract compose(): void;
+    /**
+     * Handle the response from handlers for fetch requests and convert to Web API Response.
+     * @param request Web API Request object
+     * @param file Response file or list from handler
+     * @returns Promise resolving to Web API Response object
+     */
+    protected handleFetchResponse(request: Request, file: ResponseFile<TFile> | ResponseList<TFile>): Promise<globalThis.Response>;
+    /**
+     * Convert headers to Web API Headers format by flattening arrays and converting to strings.
+     * @param headers Headers object with potentially array values
+     * @returns Headers object with all values as strings
+     */
+    protected convertHeaders(headers: Record<string, number | string | string[]>): Record<string, string>;
+    /**
+     * Create Web API Response from UploadResponse object.
+     * @param uploadResponse Upload response containing body, headers, and status code
+     * @returns Web API Response object
+     */
+    protected createResponse(uploadResponse: UploadResponse): globalThis.Response;
+    /**
+     * Create error Response from Error object with appropriate status code and message.
+     * @param error Error object to convert to HTTP error response
+     * @returns Web API Response object with error details
+     */
+    protected createErrorResponse(error: Error): Promise<globalThis.Response>;
+    /**
+     * Build file URL from request and file data.
+     * @param request Web API Request object
+     * @param file File object containing ID and content type
+     * @returns Constructed file URL with extension based on content type
+     */
+    protected buildFileUrl(request: Request, file: TFile): string;
+    /**
+     * Negotiates content type based on Accept header and supported formats.
+     * @param request Web API Request object containing Accept header.
+     * @param supportedTypes Array of supported MIME types to match against.
+     * @returns Best matching content type or undefined if no match found.
+     */
+    negotiateContentType(request: Request, supportedTypes: string[]): string | undefined;
+}
+export default BaseHandlerFetch;

package/dist/handler/base/base-handler-node.d.ts

@@ -0,0 +1,137 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Readable } from "node:stream";
+import type { UploadFile } from "../../storage/utils/index.d.ts";
+import type { UploadResponse } from "../../utils/types.d.ts";
+import type { AsyncHandler, Handlers, MethodHandler, ResponseFile, ResponseList, UploadOptions } from "../types.d.ts";
+import BaseHandlerCore from "./base-handler-core.d.ts";
+/**
+ * Base handler for Node.js platform (IncomingMessage/ServerResponse).
+ * Extends BaseHandlerCore with Node.js-specific request/response handling.
+ * @template TFile The file type used by this handler.
+ * @template NodeRequest The Node.js request type.
+ * @template NodeResponse The Node.js response type.
+ */
+declare abstract class BaseHandlerNode<TFile extends UploadFile, NodeRequest extends IncomingMessage = IncomingMessage, NodeResponse extends ServerResponse = ServerResponse> extends BaseHandlerCore<TFile> implements MethodHandler<NodeRequest, NodeResponse> {
+    /**
+     * Limiting enabled HTTP method handler.
+     */
+    static readonly methods: Handlers[];
+    /**
+     * Map of registered HTTP method handlers.
+     */
+    protected registeredHandlers: Map<string, AsyncHandler<NodeRequest, NodeResponse>>;
+    constructor(options: UploadOptions<TFile>);
+    /**
+     * Gets the registered handlers map.
+     * @returns Map of registered handlers.
+     */
+    get handlers(): Map<string, AsyncHandler<NodeRequest, NodeResponse>>;
+    /**
+     * Handles HTTP request (alias for upload method).
+     * @param request Node.js IncomingMessage.
+     * @param response Node.js ServerResponse.
+     */
+    handle: (request: NodeRequest, response: NodeResponse) => Promise<void>;
+    /**
+     * Main upload handler that processes HTTP requests and routes them to appropriate method handlers.
+     * @param request Node.js IncomingMessage.
+     * @param response Node.js ServerResponse.
+     * @param next Optional Express-style next function for middleware compatibility.
+     * @throws {UploadError} When storage is not ready or method is not allowed.
+     */
+    upload: (request: NodeRequest, response: NodeResponse, next?: () => void) => Promise<void>;
+    /**
+     * Compose and register HTTP method handlers.
+     * Subclasses should override this to register their specific handlers.
+     */
+    protected abstract compose(): void;
+    /**
+     * Sends an HTTP response with the provided body, headers, and status code.
+     * @param response Node.js ServerResponse to send data to.
+     * @param body Response body, headers, and status code.
+     */
+    send(response: NodeResponse, { body, headers, statusCode }: UploadResponse): void;
+    /**
+     * Sends an error response to the client with appropriate status code and message.
+     * @param response Node.js ServerResponse to send error to.
+     * @param error Error object to convert to HTTP error response.
+     */
+    sendError(response: NodeResponse, error: Error): Promise<void>;
+    /**
+     * Sends streaming response to client with proper backpressure handling and range request support.
+     * @param response Node.js ServerResponse to stream data to.
+     * @param stream Readable stream containing the file data.
+     * @param options Streaming options including headers, range, size, and status code.
+     */
+    sendStream(response: NodeResponse, stream: Readable, { headers, range, size, statusCode, }: {
+        headers?: Record<string, string | number>;
+        range?: {
+            end: number;
+            start: number;
+        };
+        size?: number;
+        statusCode?: number;
+    }): void;
+    /**
+     * Finish upload by sending final response to client with completed file data.
+     * @param _request HTTP request (unused parameter)
+     * @param response HTTP response object to send final response to
+     * @param uploadResponse Final upload response data containing body, headers, and status code
+     */
+    protected finish(_request: NodeRequest, response: NodeResponse, uploadResponse: UploadResponse | ResponseFile<TFile>): void;
+    /**
+     * Build file URL from request and file data.
+     * @param request HTTP request with optional originalUrl property
+     * @param file File object containing ID and content type
+     * @returns Constructed file URL with extension based on content type
+     */
+    protected buildFileUrl(request: NodeRequest & {
+        originalUrl?: string;
+    }, file: TFile): string;
+    /**
+     * Negotiates content type based on Accept header and supported formats.
+     * @param request HTTP request object containing Accept header.
+     * @param supportedTypes Array of supported MIME types to match against.
+     * @returns Best matching content type or undefined if no match found.
+     */
+    negotiateContentType(request: NodeRequest, supportedTypes: string[]): string | undefined;
+    /**
+     * Default OPTIONS handler.
+     * @param _request HTTP request (unused)
+     * @param _response HTTP response (unused)
+     * @returns Promise resolving to ResponseFile with CORS headers
+     */
+    options(_request: NodeRequest, _response: NodeResponse): Promise<ResponseFile<TFile>>;
+    /**
+     * Retrieves a file or list of files based on the request path.
+     * @param request Node.js IncomingMessage with optional originalUrl.
+     * @param response Node.js ServerResponse.
+     * @returns Promise resolving to a single file, paginated list, or array of files.
+     * @throws {UploadError} When file is not found or storage error occurs.
+     */
+    get(request: NodeRequest & {
+        originalUrl?: string;
+    }, _response: NodeResponse): Promise<ResponseFile<TFile> | ResponseList<TFile>>;
+    /**
+     * Returns a list of uploaded files with optional pagination support.
+     * @param request Node.js IncomingMessage containing query parameters for pagination.
+     * @param _response Node.js ServerResponse (unused).
+     * @returns Promise resolving to a paginated or complete list of uploaded files.
+     */
+    list(request: NodeRequest, _response: NodeResponse): Promise<ResponseList<TFile>>;
+    /**
+     * Streams download of a file with resumable support using HTTP range requests.
+     * @param request Node.js IncomingMessage with optional originalUrl and range header.
+     * @param response Node.js ServerResponse to stream the file to.
+     * @throws {HttpError} When file is not found or streaming is not supported.
+     */
+    download(request: NodeRequest & {
+        originalUrl?: string;
+    }, response: NodeResponse): Promise<void>;
+    /**
+     * Check if error is related to undefined ID or path and throw appropriate HTTP error.
+     * @param error Error object to check
+     */
+    protected checkForUndefinedIdOrPath(error: unknown): void;
+}
+export default BaseHandlerNode;

package/dist/handler/http/fetch/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Multipart } from "../../multipart/multipart-fetch.d.ts";
+export { default as Rest } from "../../rest/rest-fetch.d.ts";
+export { Tus, TUS_RESUMABLE, TUS_VERSION } from "../../tus/tus-fetch.d.ts";
+export type { AsyncHandler, BaseHandler, Handlers, MethodHandler, RequestEvent, UploadErrorEvent, UploadEvent, UploadOptions } from "../../types.d.ts";

package/dist/handler/http/fetch/index.js

@@ -0,0 +1,4 @@
+export { default as Multipart } from '../../../packem_shared/Multipart-CNFK_Okz.js';
+export { default as Rest } from '../../../packem_shared/Rest-CAOAEkOj.js';
+export { Tus } from '../../../packem_shared/Tus-B8PmlMgR.js';
+export { TUS_RESUMABLE, TUS_VERSION } from '../../../packem_shared/TUS_RESUMABLE-GJzZ9R-f.js';

package/dist/handler/http/hono/index.d.ts

@@ -0,0 +1,67 @@
+import type { Hono } from "hono";
+import type { UploadFile } from "../../../storage/utils/index.d.ts";
+import type { UploadOptions } from "../../types.d.ts";
+/**
+ * Registers upload handler routes on a Hono app instance.
+ * Automatically registers all required HTTP methods for the specified handler type.
+ * @param app Hono app instance to register routes on
+ * @param config Handler configuration including storage, type, and path
+ * @example
+ * ```ts
+ * import { Hono } from "hono";
+ * import { DiskStorage } from "@visulima/storage";
+ * import { createHonoHandler } from "@visulima/storage/handler/http/hono";
+ *
+ * const app = new Hono();
+ * const storage = new DiskStorage({ directory: "./uploads" });
+ *
+ * // Multipart handler - automatically registers POST, GET, DELETE, OPTIONS
+ * createHonoHandler(app, {
+ *   path: "/files",
+ *   storage,
+ *   type: "multipart"
+ * });
+ * ```
+ * @example
+ * ```ts
+ * import { Hono } from "hono";
+ * import { DiskStorage } from "@visulima/storage";
+ * import { createHonoHandler } from "@visulima/storage/handler/http/hono";
+ *
+ * const app = new Hono();
+ * const storage = new DiskStorage({ directory: "./uploads" });
+ *
+ * // REST handler - automatically registers POST, PUT, PATCH, GET, HEAD, DELETE, OPTIONS
+ * createHonoHandler(app, {
+ *   path: "/files-rest",
+ *   storage,
+ *   type: "rest"
+ * });
+ * ```
+ * @example
+ * ```ts
+ * import { Hono } from "hono";
+ * import { DiskStorage } from "@visulima/storage";
+ * import { createHonoHandler } from "@visulima/storage/handler/http/hono";
+ *
+ * const app = new Hono();
+ * const storage = new DiskStorage({ directory: "./uploads" });
+ *
+ * // TUS handler - automatically registers POST, PATCH, HEAD, GET, DELETE, OPTIONS
+ * createHonoHandler(app, {
+ *   path: "/files-tus",
+ *   storage,
+ *   type: "tus"
+ * });
+ * ```
+ */
+export declare const createStorageHandler: <TFile extends UploadFile>(app: Hono, config: HonoHandlerConfig<TFile>) => void;
+/**
+ * Configuration for Hono handler.
+ */
+export interface HonoHandlerConfig<TFile extends UploadFile> extends UploadOptions<TFile> {
+    /** Base path for the routes (e.g., "/files" or "/api/upload") */
+    path: string;
+    /** Handler type to use */
+    type: "multipart" | "rest" | "tus";
+}