vovk 3.5.1 → 3.7.0

package/dist/core/controllers-to-static-params.js

@@ -0,0 +1,32 @@
+/**
+ * Generates static API of the given controllers for a static segment.
+ * @see https://vovk.dev/segment
+ * @example
+ * ```ts
+ * export function generateStaticParams() {
+ *  return controllersToStaticParams(controllers);
+ * }
+ */
+export function controllersToStaticParams(c, slug = 'vovk') {
+    const controllers = c;
+    return [
+        { [slug]: ['_schema_'] },
+        ...Object.values(controllers).flatMap((controller) => {
+            const handlers = controller._handlers;
+            const splitPrefix = controller.prefix?.split('/') ?? [];
+            return Object.entries(handlers ?? {}).flatMap(([name, handler]) => {
+                const staticParams = controller._handlersMetadata?.[name]?.staticParams;
+                if (staticParams?.length) {
+                    return staticParams.map((paramsItem) => {
+                        let path = handler.path;
+                        for (const [key, value] of Object.entries(paramsItem ?? {})) {
+                            path = path.replace(`{${key}}`, value);
+                        }
+                        return { [slug]: [...splitPrefix, ...path.split('/')].filter(Boolean) };
+                    });
+                }
+                return [{ [slug]: [...splitPrefix, ...handler.path.split('/')].filter(Boolean) }];
+            });
+        }),
+    ];
+}

package/dist/core/create-decorator.d.ts

@@ -0,0 +1,12 @@
+import type { VovkHandlerSchema, VovkController } from '../types/core.js';
+import type { VovkRequest } from '../types/request.js';
+import type { KnownAny } from '../types/utils.js';
+type Next = () => Promise<unknown>;
+/**
+ * Creates a custom decorator for Vovk controllers.
+ * @see https://vovk.dev/decorator
+ */
+export declare function createDecorator<TArgs extends unknown[], TRequest = VovkRequest>(handler: null | ((this: VovkController, req: TRequest, next: Next, ...args: TArgs) => unknown), initHandler?: (this: VovkController, ...args: TArgs) => Omit<VovkHandlerSchema, 'path' | 'httpMethod'> | ((handlerSchema: VovkHandlerSchema | null, options: {
+    handlerName: string;
+}) => Omit<Partial<VovkHandlerSchema>, 'path' | 'httpMethod'>) | null | undefined): (...args: TArgs) => (target: KnownAny, propertyKeyOrContext?: unknown) => KnownAny;
+export {};

package/dist/core/create-decorator.js

@@ -0,0 +1,52 @@
+import { applyDecoratorAdapter } from './apply-decorator-adapter.js';
+/**
+ * Creates a custom decorator for Vovk controllers.
+ * @see https://vovk.dev/decorator
+ */
+export function createDecorator(handler, initHandler) {
+    return function decoratorCreator(...args) {
+        return function decorator(target, propertyKeyOrContext) {
+            return applyDecoratorAdapter(target, propertyKeyOrContext, applyDecorator);
+            function applyDecorator(controller, propertyKey) {
+                const originalMethod = controller[propertyKey];
+                if (typeof originalMethod !== 'function') {
+                    throw new Error(`Unable to decorate: ${propertyKey} is not a function`);
+                }
+                const sourceMethod = originalMethod._sourceMethod ?? originalMethod;
+                const method = function method(req, params) {
+                    const next = async () => {
+                        return await originalMethod.call(controller, req, params);
+                    };
+                    return handler ? handler.call(controller, req, next, ...args) : next();
+                };
+                controller[propertyKey] = method;
+                method._controller = controller;
+                method._sourceMethod = sourceMethod;
+                method.fn = originalMethod.fn;
+                method.definition = originalMethod.definition;
+                sourceMethod.wrapper = method;
+                // TODO define internal method type
+                originalMethod._controller = controller;
+                const handlerSchema = controller._handlers?.[propertyKey] ?? null;
+                const initResultReturn = initHandler?.call(controller, ...args);
+                const initResult = typeof initResultReturn === 'function'
+                    ? initResultReturn(handlerSchema, {
+                        handlerName: propertyKey,
+                    })
+                    : initResultReturn;
+                const methodSchema = {
+                    ...handlerSchema,
+                    // avoid override of path and httpMethod
+                    ...(initResult?.validation ? { validation: initResult.validation } : {}),
+                    ...(initResult?.operationObject ? { operationObject: initResult.operationObject } : {}),
+                    ...(initResult?.misc ? { misc: initResult.misc } : {}),
+                };
+                method.schema = methodSchema;
+                controller._handlers = {
+                    ...controller._handlers,
+                    [propertyKey]: methodSchema,
+                };
+            }
+        };
+    };
+}

package/dist/core/decorators.js

@@ -1,7 +1,7 @@
-import { vovkApp } from './vovkApp.js';
-import { trimPath } from '../utils/trimPath.js';
-import { toKebabCase } from '../utils/toKebabCase.js';
-import { applyDecoratorAdapter } from './applyDecoratorAdapter.js';
+import { vovkApp } from './vovk-app.js';
+import { trimPath } from '../utils/trim-path.js';
+import { toKebabCase } from '../utils/to-kebab-case.js';
+import { applyDecoratorAdapter } from './apply-decorator-adapter.js';
 import { HttpMethod } from '../types/enums.js';
 const isClass = (func) => typeof func === 'function' && /class/.test(func.toString());
 const assignSchema = ({ controller, propertyKey, path, options, httpMethod, }) => {

package/dist/core/get-schema.d.ts

@@ -0,0 +1,21 @@
+import type { VovkSegmentSchema, VovkController } from '../types/core.js';
+import type { StaticClass } from '../types/utils.js';
+export declare function getControllerSchema(controller: VovkController, rpcModuleName: string, exposeValidation: boolean): Promise<{
+    rpcModuleName: string;
+    originalControllerName: string;
+    prefix: string;
+    handlers: {
+        [k: string]: {
+            path: string;
+            httpMethod: string;
+            operationObject?: import("../internal.js").VovkOperationObject;
+            misc?: Record<string, unknown>;
+        };
+    };
+}>;
+export declare function getSchema(options: {
+    emitSchema?: boolean;
+    segmentName?: string;
+    controllers: Record<string, StaticClass>;
+    exposeValidation?: boolean;
+}): Promise<VovkSegmentSchema>;

package/dist/core/get-schema.js

@@ -0,0 +1,31 @@
+import { VovkSchemaIdEnum } from '../types/enums.js';
+export async function getControllerSchema(controller, rpcModuleName, exposeValidation) {
+    const handlers = exposeValidation
+        ? (controller._handlers ?? {})
+        : Object.fromEntries(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        Object.entries(controller._handlers ?? {}).map(([key, { validation: _v, ...value }]) => [key, value]));
+    return {
+        rpcModuleName,
+        originalControllerName: controller.name,
+        prefix: controller.prefix ?? '',
+        handlers,
+    };
+}
+export async function getSchema(options) {
+    const exposeValidation = options?.exposeValidation ?? true;
+    const emitSchema = options.emitSchema ?? true;
+    const schema = {
+        $schema: VovkSchemaIdEnum.SEGMENT,
+        emitSchema,
+        segmentName: options.segmentName ?? '',
+        segmentType: 'segment',
+        controllers: {},
+    };
+    if (!emitSchema)
+        return schema;
+    for (const [rpcModuleName, controller] of Object.entries(options.controllers ?? {})) {
+        schema.controllers[rpcModuleName] = await getControllerSchema(controller, rpcModuleName, exposeValidation);
+    }
+    return schema;
+}

package/dist/core/http-exception.d.ts

@@ -0,0 +1,16 @@
+import type { VovkErrorResponse } from '../types/core.js';
+import type { HttpStatus } from '../types/enums.js';
+/**
+ * Represents an HTTP exception with a status code and message.
+ * @example
+ * ```ts
+ * throw new HttpException(HttpStatus.BAD_REQUEST, 'Invalid request data');
+ * ```
+ */
+export declare class HttpException extends Error {
+    statusCode: HttpStatus;
+    message: string;
+    cause?: unknown;
+    constructor(statusCode: HttpStatus, message: string, cause?: unknown);
+    toJSON(): VovkErrorResponse;
+}

package/dist/core/http-exception.js

@@ -0,0 +1,26 @@
+/**
+ * Represents an HTTP exception with a status code and message.
+ * @example
+ * ```ts
+ * throw new HttpException(HttpStatus.BAD_REQUEST, 'Invalid request data');
+ * ```
+ */
+export class HttpException extends Error {
+    statusCode;
+    message;
+    cause;
+    constructor(statusCode, message, cause) {
+        super(message);
+        this.statusCode = statusCode;
+        this.message = message;
+        this.cause = cause;
+    }
+    toJSON() {
+        return {
+            isError: true,
+            statusCode: this.statusCode,
+            message: this.message,
+            ...(this.cause ? { cause: this.cause } : {}),
+        };
+    }
+}

package/dist/core/init-segment.d.ts

@@ -0,0 +1,33 @@
+import type { VovkRequest } from '../types/request.js';
+import type { StaticClass } from '../types/utils.js';
+export declare const initSegment: (options: {
+    segmentName?: string;
+    controllers: Record<string, StaticClass>;
+    exposeValidation?: boolean;
+    emitSchema?: boolean;
+    onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
+    onSuccess?: (resp: unknown, req: VovkRequest) => void | Promise<void>;
+    onBefore?: (req: VovkRequest) => void | Promise<void>;
+}) => {
+    GET: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    POST: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    PUT: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    PATCH: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    DELETE: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    HEAD: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    OPTIONS: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+};

package/dist/core/init-segment.js

@@ -0,0 +1,62 @@
+import { vovkApp } from './vovk-app.js';
+import { trimPath } from '../utils/trim-path.js';
+import { getSchema } from './get-schema.js';
+export const initSegment = (options) => {
+    const segmentName = trimPath(options.segmentName ?? '');
+    options.segmentName = segmentName;
+    const controllerEntries = Object.entries(options.controllers ?? {});
+    const controllerSet = new Set(controllerEntries.map(([, c]) => c));
+    // Sort so parent controllers are initialized before their children
+    controllerEntries.sort(([, a], [, b]) => {
+        return (Number(controllerSet.has(Object.getPrototypeOf(a))) -
+            Number(controllerSet.has(Object.getPrototypeOf(b))));
+    });
+    for (const [rpcModuleName, controller] of controllerEntries) {
+        controller._segmentName = segmentName;
+        controller._rpcModuleName = rpcModuleName;
+        controller._onError = options?.onError;
+        controller._onSuccess = options?.onSuccess;
+        controller._onBefore = options?.onBefore;
+        // Apply deferred decorate() decorator appliers in reverse order (bottom-up, matching stacked decorator semantics)
+        for (const key of Object.getOwnPropertyNames(controller)) {
+            const appliers = controller[key]?._decorateMetadata
+                ?.decoratorAppliers;
+            if (appliers) {
+                for (let i = appliers.length - 1; i >= 0; i--) {
+                    appliers[i](controller, key);
+                }
+            }
+        }
+        // Re-clone metadata if this controller extends another registered controller
+        // (cloneControllerMetadata() runs at class-definition time, before decorate() metadata is applied)
+        const parent = Object.getPrototypeOf(controller);
+        if (controllerSet.has(parent) && parent._handlers) {
+            controller._handlers = { ...parent._handlers, ...controller._handlers };
+            controller._handlersMetadata = { ...parent._handlersMetadata, ...controller._handlersMetadata };
+            for (const methods of Object.values(vovkApp.routes)) {
+                methods.set(controller, { ...(methods.get(parent) ?? {}), ...methods.get(controller) });
+            }
+        }
+    }
+    async function GET_DEV(req, data) {
+        const params = await data.params;
+        if (params[Object.keys(params)[0]]?.[0] === '_schema_') {
+            const schema = await getSchema(options);
+            return vovkApp.respond({
+                req,
+                statusCode: 200,
+                responseBody: { schema },
+            });
+        }
+        return vovkApp.GET(req, data, segmentName);
+    }
+    return {
+        GET: process.env.NODE_ENV === 'development' ? GET_DEV : (req, data) => vovkApp.GET(req, data, segmentName),
+        POST: (req, data) => vovkApp.POST(req, data, segmentName),
+        PUT: (req, data) => vovkApp.PUT(req, data, segmentName),
+        PATCH: (req, data) => vovkApp.PATCH(req, data, segmentName),
+        DELETE: (req, data) => vovkApp.DELETE(req, data, segmentName),
+        HEAD: (req, data) => vovkApp.HEAD(req, data, segmentName),
+        OPTIONS: (req, data) => vovkApp.OPTIONS(req, data, segmentName),
+    };
+};

package/dist/core/json-lines-responder.d.ts

@@ -0,0 +1,42 @@
+import type { StreamAbortMessage } from '../types/core.js';
+import '../utils/shim.js';
+export declare abstract class Responder {
+    response: Response;
+}
+/**
+ * A Responder subclass for streaming JSON Lines (JSONL) data.
+ * @see https://vovk.dev/jsonlines
+ * @param request The incoming Request object.
+ * @param getResponse Optional function to create a custom Response object.
+ * @example
+ * ```ts
+ * import { JSONLinesResponder } from 'vovk';
+ *
+ * const responder = new JSONLinesResponder<MyItemType>(request, (responder) => {
+ *   return new Response(responder.readableStream, { headers: responder.headers });
+ * });
+ *
+ * // Send items
+ * responder.send({ ... });
+ * // Close the stream when done
+ * responder.close();
+ * // Or throw an error
+ * responder.throw(new Error('Something went wrong'));
+ * // get the Response object, headers, etc.
+ * const { response, headers } = responder;
+ * ```
+ */
+export declare class JSONLinesResponder<T> extends Responder {
+    private isClosed;
+    private i;
+    private controller?;
+    private readonly encoder;
+    readonly readableStream: ReadableStream | null;
+    readonly headers: Record<string, string>;
+    onBeforeSend: (item: T, i: number) => T | Promise<T>;
+    constructor(request?: Request | null, getResponse?: (responder: JSONLinesResponder<T>) => Response);
+    readonly send: (item: T) => Promise<void>;
+    sendLineOrError: (data: T | StreamAbortMessage) => void;
+    readonly close: () => void;
+    readonly throw: (e: unknown) => void;
+}

package/dist/core/json-lines-responder.js

@@ -0,0 +1,94 @@
+import '../utils/shim.js';
+export class Responder {
+    response;
+}
+/**
+ * A Responder subclass for streaming JSON Lines (JSONL) data.
+ * @see https://vovk.dev/jsonlines
+ * @param request The incoming Request object.
+ * @param getResponse Optional function to create a custom Response object.
+ * @example
+ * ```ts
+ * import { JSONLinesResponder } from 'vovk';
+ *
+ * const responder = new JSONLinesResponder<MyItemType>(request, (responder) => {
+ *   return new Response(responder.readableStream, { headers: responder.headers });
+ * });
+ *
+ * // Send items
+ * responder.send({ ... });
+ * // Close the stream when done
+ * responder.close();
+ * // Or throw an error
+ * responder.throw(new Error('Something went wrong'));
+ * // get the Response object, headers, etc.
+ * const { response, headers } = responder;
+ * ```
+ */
+export class JSONLinesResponder extends Responder {
+    isClosed = false;
+    i = 0;
+    controller;
+    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: biome bug
+    encoder;
+    readableStream;
+    headers;
+    onBeforeSend = (item) => item;
+    constructor(request, getResponse) {
+        super();
+        const encoder = new TextEncoder();
+        let readableController;
+        const readableStream = new ReadableStream({
+            cancel: () => {
+                this.isClosed = true;
+            },
+            start: (controller) => {
+                readableController = controller;
+            },
+        });
+        const accept = request?.headers?.get('accept');
+        const headers = {
+            'content-type': accept?.includes('application/jsonl')
+                ? 'application/jsonl; charset=utf-8'
+                : 'text/plain; charset=utf-8',
+        };
+        this.headers = headers;
+        this.readableStream = readableStream;
+        this.encoder = encoder;
+        // biome-ignore lint/style/noNonNullAssertion: assigned at readableStream start
+        this.controller = readableController;
+        this.response = getResponse?.(this) ?? new Response(readableStream, { headers });
+        request?.signal?.addEventListener('abort', this.close, { once: true });
+        // this will make promise on the client-side to resolve immediately, before sending the first JSON line
+        this.controller?.enqueue(encoder?.encode(''));
+    }
+    send = async (item) => {
+        try {
+            // onBeforeSend is set by withValidationLibrary if iteration validation is provided
+            // in case if data is streamed immediately in a controller/service, we're going to lose the first iteration validation
+            // the await with zero timeout ensures onBeforeSend is set before the first send
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            this.sendLineOrError(await this.onBeforeSend(item, this.i++));
+        }
+        catch (e) {
+            this.throw(e);
+        }
+    };
+    sendLineOrError = (data) => {
+        const { controller, encoder } = this;
+        if (this.isClosed)
+            return;
+        controller?.enqueue(encoder?.encode(`${JSON.stringify(data)}\n`));
+    };
+    close = () => {
+        const { controller } = this;
+        if (this.isClosed)
+            return;
+        this.isClosed = true;
+        controller?.close();
+    };
+    throw = (e) => {
+        this.sendLineOrError({ isError: true, reason: e instanceof Error ? e.message : e });
+        return this.close();
+    };
+}

package/dist/core/resolve-generator-config-values.d.ts

@@ -0,0 +1,19 @@
+import type { OpenAPIObject } from 'openapi3-ts/oas31';
+import type { VovkConfig, VovkOutputConfig, VovkPackageJson, VovkReadmeConfig, VovkSamplesConfig } from '../types/config.js';
+import type { PackageJson } from '../types/package.js';
+export declare function resolveGeneratorConfigValues({ config, outputConfigs, forceOutputConfigs, segmentName, isBundle, projectPackageJson, }: {
+    config: VovkConfig | undefined;
+    outputConfigs: VovkOutputConfig[];
+    forceOutputConfigs?: VovkOutputConfig[];
+    segmentName: string | null;
+    isBundle: boolean;
+    projectPackageJson: PackageJson | undefined;
+}): {
+    readme: VovkReadmeConfig;
+    openAPIObject: OpenAPIObject;
+    samples: VovkSamplesConfig;
+    origin: string;
+    package: VovkPackageJson;
+    imports: VovkOutputConfig['imports'];
+    reExports: VovkOutputConfig['reExports'];
+};

package/dist/core/resolve-generator-config-values.js

@@ -0,0 +1,59 @@
+import { deepExtend } from '../utils/deep-extend.js';
+export function resolveGeneratorConfigValues({ config, outputConfigs, forceOutputConfigs, segmentName, isBundle, projectPackageJson, }) {
+    const packageJson = deepExtend(Object.fromEntries(Object.entries(projectPackageJson ?? {}).filter(([key]) => [
+        'name',
+        'version',
+        'description',
+        'license',
+        'author',
+        'contributors',
+        'repository',
+        'homepage',
+        'bugs',
+        'keywords',
+    ].includes(key))), config?.outputConfig?.package, typeof segmentName === 'string' ? config?.outputConfig?.segments?.[segmentName]?.package : undefined, outputConfigs?.reduce((acc, config) => deepExtend(acc, config.package), {}), isBundle ? config?.bundle?.outputConfig?.package : undefined);
+    const openAPIObject = deepExtend({
+        openapi: '3.1.0',
+        info: {
+            title: packageJson.name,
+            version: packageJson.version,
+            description: packageJson.description,
+        },
+    }, config?.outputConfig?.openAPIObject, typeof segmentName === 'string' ? config?.outputConfig?.segments?.[segmentName]?.openAPIObject : undefined, outputConfigs?.reduce((acc, config) => deepExtend(acc, config.openAPIObject), {}), isBundle ? config?.bundle?.outputConfig?.openAPIObject : undefined, forceOutputConfigs?.reduce((acc, config) => deepExtend(acc, config.openAPIObject), {}));
+    const samples = deepExtend({}, config?.outputConfig?.samples, typeof segmentName === 'string' ? config?.outputConfig?.segments?.[segmentName]?.samples : undefined, outputConfigs?.reduce((acc, config) => deepExtend(acc, config.samples), {}), isBundle ? config?.bundle?.outputConfig?.samples : undefined, forceOutputConfigs?.reduce((acc, config) => deepExtend(acc, config.samples), {}));
+    const readme = deepExtend({}, config?.outputConfig?.readme, typeof segmentName === 'string' ? config?.outputConfig?.segments?.[segmentName]?.readme : undefined, outputConfigs?.reduce((acc, config) => deepExtend(acc, config.readme), {}), isBundle ? config?.bundle?.outputConfig?.readme : undefined, forceOutputConfigs?.reduce((acc, config) => deepExtend(acc, config.readme), {}));
+    const origin = [
+        config?.outputConfig?.origin,
+        typeof segmentName === 'string' ? config?.outputConfig?.segments?.[segmentName]?.origin : undefined,
+        ...(outputConfigs?.map((config) => config.origin) ?? []),
+        isBundle ? config?.bundle?.outputConfig?.origin : undefined,
+        ...(forceOutputConfigs?.map((config) => config.origin) ?? []),
+    ]
+        .filter(Boolean)
+        .at(-1)
+        // remove trailing slash if any
+        ?.replace(/\/$/, '') ?? '';
+    const imports = deepExtend({
+        fetcher: 'vovk/fetcher',
+        validateOnClient: null,
+        createRPC: 'vovk/create-rpc',
+    }, config?.outputConfig?.imports, typeof segmentName === 'string' ? config?.outputConfig?.segments?.[segmentName]?.imports : undefined, outputConfigs?.reduce((acc, config) => deepExtend(acc, config.imports), {}), isBundle ? config?.bundle?.outputConfig?.imports : undefined, forceOutputConfigs?.reduce((acc, config) => deepExtend(acc, config.imports), {}));
+    const reExports = deepExtend(
+    // segmentName can be an empty string (for the root segment) and null (for composed clients)
+    // therefore, !segmentName indicates that this either a composed client or a root segment of a segmented client
+    {}, !segmentName && config?.outputConfig?.reExports, 
+    // for segmented client, apply all reExports from all segments
+    typeof segmentName !== 'string' &&
+        Object.values(config?.outputConfig?.segments ?? {}).reduce((acc, segmentConfig) => deepExtend(acc, segmentConfig.reExports ?? {}), {}), 
+    // for a specific segment, apply reExports from that segment
+    typeof segmentName === 'string' ? config?.outputConfig?.segments?.[segmentName]?.reExports : undefined, outputConfigs?.reduce((acc, config) => deepExtend(acc, config.reExports), {}), isBundle ? config?.bundle?.outputConfig?.reExports : undefined, forceOutputConfigs?.reduce((acc, config) => deepExtend(acc, config.reExports), {}));
+    return {
+        package: packageJson,
+        openAPIObject,
+        samples,
+        readme,
+        origin,
+        imports,
+        reExports,
+    };
+}

package/dist/core/set-handler-schema.d.ts

@@ -0,0 +1,4 @@
+import type { VovkController, VovkHandlerSchema } from '../types/core.js';
+export declare function setHandlerSchema(h: ((...args: unknown[]) => unknown) & {
+    _getSchema?: (controller: VovkController) => Omit<VovkHandlerSchema, 'httpMethod' | 'path'>;
+}, schema: Omit<VovkHandlerSchema, 'httpMethod' | 'path'>): Promise<void>;

package/dist/core/set-handler-schema.js

@@ -0,0 +1,12 @@
+export async function setHandlerSchema(h, schema) {
+    h._getSchema = (controller) => {
+        if (!controller) {
+            throw new Error('Error setting client validators. Controller not found. Did you forget to use an HTTP decorator?');
+        }
+        const handlerName = Object.getOwnPropertyNames(controller).find((key) => controller[key]._sourceMethod === h);
+        if (!handlerName) {
+            throw new Error('Error setting client validators. Handler not found.');
+        }
+        return schema;
+    };
+}

package/dist/core/to-download-response.d.ts

@@ -0,0 +1,11 @@
+type BinaryData = Blob | File | ArrayBuffer | Uint8Array | ReadableStream<Uint8Array> | string;
+/**
+ * Creates a Response object for downloading binary data with appropriate headers.
+ * @see https://vovk.dev/response
+ */
+export declare function toDownloadResponse(data: BinaryData, { filename, type, headers }?: {
+    filename?: string;
+    type?: string;
+    headers?: Record<string, string>;
+}): Response;
+export {};

package/dist/core/to-download-response.js

@@ -0,0 +1,25 @@
+import { fileNameToDisposition } from '../utils/file-name-to-disposition.js';
+/**
+ * Creates a Response object for downloading binary data with appropriate headers.
+ * @see https://vovk.dev/response
+ */
+export function toDownloadResponse(data, { filename, type, headers } = {}) {
+    const body = data instanceof Blob
+        ? data
+        : data instanceof ReadableStream
+            ? data
+            : new Blob([data], { type: type ?? 'application/octet-stream' });
+    const resolvedName = filename ?? (data instanceof File ? data.name : undefined);
+    const resolvedType = type ?? (body instanceof Blob ? body.type : undefined);
+    return new Response(body, {
+        headers: {
+            ...(resolvedType ? { 'Content-Type': resolvedType } : {}),
+            ...(resolvedName
+                ? {
+                    'Content-Disposition': fileNameToDisposition(resolvedName),
+                }
+                : {}),
+            ...headers,
+        },
+    });
+}

package/dist/core/vovk-app.d.ts

@@ -0,0 +1,36 @@
+import { HttpMethod, HttpStatus } from '../types/enums.js';
+import type { RouteHandler, VovkController, DecoratorOptions } from '../types/core.js';
+declare class VovkApp {
+    #private;
+    private static getHeadersFromDecoratorOptions;
+    routes: Record<HttpMethod, Map<VovkController, Record<string, RouteHandler>>>;
+    GET: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }, segmentName: string) => Promise<Response>;
+    POST: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }, segmentName: string) => Promise<Response>;
+    PUT: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }, segmentName: string) => Promise<Response>;
+    PATCH: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }, segmentName: string) => Promise<Response>;
+    DELETE: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }, segmentName: string) => Promise<Response>;
+    HEAD: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }, segmentName: string) => Promise<Response>;
+    OPTIONS: (req: Request, data: {
+        params: Promise<Record<string, string[]>>;
+    }, segmentName: string) => Promise<Response>;
+    respond: ({ statusCode, responseBody, options, }: {
+        req: Request;
+        statusCode: HttpStatus;
+        responseBody: unknown;
+        options?: DecoratorOptions;
+    }) => Promise<Response>;
+}
+declare const vovkApp: VovkApp;
+export { vovkApp };