@wooksjs/event-http 0.2.8 → 0.2.10

package/README.md

@@ -48,539 +48,6 @@ app.on('GET', 'hello/:name', () => `Hello ${ useRouteParams().get('name') }!`)
 app.listen(3000, () => { console.log('Wooks Server is up on port 3000') })
 ```
 
-### Get More Control on Server
-You can create http(s) server manually and pass server callback from the wooks http app:
+## Documentation
 
-```js
-import { useRouteParams } from 'wooks'
-import { createHttpApp } from '@wooksjs/event-http'
-import http from 'http' // or https
-
-const app = createHttpApp()
-
-app.get('hello/:name', () => `Hello ${ useRouteParams().get('name') }!`)
-
-const server = http.createServer(app.getServerCb())
-server.listen(3000, () => { console.log('Wooks Server is up on port 3000') })
-```
-
-## Quick Navigation
- - [User Documentation](./README.md#User-Documentation)
- - [URL Parameters](./README.md#)
- - [Query Parameters](./README.md#Query-Parameters)
----
- - [Request](./README.md#Request)
- - [Request Method and Headers](./README.md#Request-Method-and-Headers)
- - [Request Cookies](./README.md#Request-Cookies)
- - [Request Authorization](./README.md#Request-Authorization)
- - [Request Body Parser](./README.md#Request-Body-Parser)
----
- - [Response](./README.md#Response)
- - [Response Headers](./README.md#Response-Headers)
- - [Response Cookies](./README.md#Response-Cookies)
- - [Response Status](./README.md#Response-Status)
- - [Cache-Control](./README.md#Cache-Control)
- - [Proxy Requests](./README.md#Proxy-Requests)
- - [Serve File](./README.md#Serve-File)
----
- - [Create you own hooks](./README.md#Create-you-own-hooks)
----
- - [Adapter Documentation](./README.md#Adapter-Documentation)
- - [Create a new wooks context](./README.md#Create-a-new-wooks-context)
- - [Create a responder](./README.md#Create-a-responder)
- - [Restore Context](./README.md#Restore-Context)
-
-## User Documentation
-
-### URL Parameters
-To get access to URL parameters use composable function `useRouteParams`
-
-```js
-import { useRouteParams } from 'wooks'
-app.get('parametric/:param1/:param2/...', () => {
-    const { params, get } = useRouteParams()
-    // presume we had a request on `/parametric/value1/value2`
-    console.log('param1=' + get('param1'))
-    // prints "param1=value1"
-    console.log('param2=' + get('param2'))
-    // prints "param2=value2"
-    console.log(params)
-    // prints {
-    //   param1: "value1",
-    //   param2: "value2" 
-    // }
-})
-```
-
-### Query Parameters
-To get access to Query parameters use composable function `useSearchParams`
-
-```js
-import { useSearchParams } from '@wooksjs/event-http'
-app.get('with-query', () => {
-    const { jsonSearchParams, urlSearchParams } = useSearchParams()
-    // presume we had a request on `/with-query?param1=abc&param2=cde`
-    console.log('param1=' + urlSearchParams('param1'))
-    // prints "param1=abc"
-    console.log('param2=' + urlSearchParams('param2'))
-    // prints "param1=cde"
-    console.log(jsonSearchParams)
-    // prints {
-    //   param1: "abc",
-    //   param2: "cde"   
-    // }
-})
-```
-
-### Request
-To get a reference to the raw request instance use composable function `useRequest`
-
-You probably don't need a `rawRequest` unless you are developing some new feature. All the base use-cases covered with other composable functions.
-
-```js
-import { useRequest } from '@wooksjs/event-http'
-app.get('test', () => {
-    const { rawRequest } = useRequest()
-})
-```
-
-### Request Method and Headers
-`useRequest` provides some more shortcuts for useful data
-
-```js
-import { useRequest } from '@wooksjs/event-http'
-app.get('test', async () => {
-    const { 
-        url,        // request url      (string) 
-        method,     // request method   (string)
-        headers,    // request headers  (object)
-        rawBody,    // request body     ((): Promise<Buffer>)
-    } = useRequest()
-
-    const body = await rawBody() // body as a Buffer
-})
-```
-
-### Request Cookies
-Cookies are not parsed unless requested. Composable function `useCookies` provides cookie getter and raw cookies string.
-
-```js
-import { useCookies } from '@wooksjs/event-http'
-app.get('test', async () => {
-    const { 
-        rawCookies, // "cookie" from headers (string | undefined)
-        getCookie,  // cookie getter ((name): string | null)
-    } = useCookies()
-
-    console.log(getCookie('session'))
-    // prints the value of the cookie with the name "session"
-})
-```
-
-### Request Authorization
-`useAuthorization` function provides useful helpers for auth-headers:
-
-```js
-import { useAuthorization } from '@wooksjs/event-http'
-app.get('test', async () => {
-    const {
-        authorization,      // the raw value of "authorization" header : string
-        authType,           // the auth type (Bearer/Basic) : string
-        authRawCredentials, // the auth credentials that follow auth type : string
-        isBasic,            // true if authType === 'Basic' : () => boolean
-        isBearer,           // true if authType === 'Bearer' : () => boolean
-        basicCredentials,   // parsed basic auth credentials : () => { username: string, password: string }
-    } = useAuthorization()
-
-    if (isBasic()) {
-        const { username, password } = basicCredentials()
-        console.log({ username, password })
-    } else if (isBearer()) {
-        const token = authRawCredentials
-        console.log({ token })
-    } else {
-        // unknown or empty authorization header
-    }
-})
-```
-
-### Request Body Parser
-[More details here](https://github.com/wooksjs/body#readme)
-
-### Response
-The easiest way to respond to the request is to return some value from handler function like this:
-```js
-app.get('string_response', () => {
-    return 'hello world!'
-    // responds with:
-    // 200
-    // Content-Length: ...
-    // Content-Type: text/plain
-    // hello world!
-})
-```
-
-Whatever is returned from the handler is the response. `Content-Type` and `Content-Length` headers will be calculated accordingly.
-
-If a handler returns a json object, it will be stringified and the header `Content-Type` will be set to `application/json` automatically:
-```js
-app.get('json_response', () => {
-    return { value: 'hello world!' }
-    // responds with:
-    // 200
-    // Content-Length: ...
-    // Content-Type: application/json
-    // { "value": "hello world!" }
-})
-```
-
-**Supported response types:**
-1. string   (text/plain, text/html, application/xml - depending on the content)
-2. object/array (application/json)
-3. boolean  (text/plain)
-4. readable stream (you must specify `Content-Type` and `Content-Length` headers yourself)
-5. fetch (native) response (streaming body to client response)
-
-**Raw Response**: When it is needed to take the full control of the response, use composable function `useResponse`
-
-When you get a raw response instance you take away the control of the response on yourself. The framework will not process the output of the handler in this case.
-
-An example of using raw response instance:
-```js
-import { useResponse } from '@wooksjs/event-http'
-app.get('test', () => {
-    const { rawResponse } = useResponse()
-    const res = rawResponse()
-    res.writeHead(200, {})
-    res.end('ok')
-})
-```
-
-If you don't want to take away a responsibility for the response but still need a raw response instance you can use `{ passthrough: true }` as an argument.
-The next example does the same thing as the previous example using `passthrough` options:
-
-```js
-import { useResponse } from '@wooksjs/event-http'
-app.get('test', () => {
-    const { rawResponse } = useResponse()
-    const res = rawResponse({ passthrough: true })
-    return 'ok'
-})
-```
-
-### Response Headers
-A function `useSetHeaders` provides variety of response headers helpers:
-
-```js
-import { useSetHeaders, contentTypes } from '@wooksjs/event-http'
-app.get('test', async () => {
-    const {
-        setHeader,      //sets header: (name: string, value: string | number) => void;
-        removeHeader,   //removes header: (name: string) => void;
-        setContentType, //sets "Content-Type": (value: string) => void;
-        headers,        //Object with response headers: Record<string, string>;
-        enableCors,     //sets "Access-Control-Allow-Origin": (origin?: string) => void;
-    } = useSetHeaders()
-
-    setContentType(contentTypes.application.json)
-    setHeader('server', 'myServer v1.0')
-    enableCors()
-    return '{ "value": "OK" }'
-})
-```
-
-Another hook for set header
-
-```js
-import { useSetHeader } from '@wooksjs/event-http'
-app.get('test', async () => {
-    const server = useSetHeader('server')
-    server.value = 'myServer v1.0'
-})
-```
-
-### Response Cookies
-A function `useSetCookies` provides variety of set-cookie helpers:
-
-```js
-import { useSetCookies } from '@wooksjs/event-http'
-app.get('test', async () => {
-    const {
-        setCookie,      // sets cookie : (name: string, value: string, attrs?) => void;
-        removeCookie,   // removes cookie from setlist : (name: string) => void;
-        clearCookies,   // removes all the cookies from setlist : () => void;
-        cookies,        // returns a value of Set-Cookie header: () => string[];
-    } = useSetCookies()
-
-    setCookie('session', 'value', {
-        expires: '2029-01-01',  // Date | string | number;
-        maxAge:  '1h',          // number | TProstoTimeMultiString;
-        domain:  'my-domain',   // string;
-        path:    '/home',       // string;
-        secure:   true,         // boolean;
-        httpOnly: false,        // boolean;
-        sameSite: true,         // boolean | 'Lax' | 'None' | 'Strict';
-    })
-})
-```
-
-Another hook for set-cookie
-
-```js
-import { useSetCookie } from '@wooksjs/event-http'
-app.get('test', async () => {
-    const session = useSetCookie('session')
-    session.value = 'value'
-    session.attrs = {
-        expires: '2029-01-01',  // Date | string | number;
-        maxAge:  '1h',          // number | TProstoTimeMultiString;
-        domain:  'my-domain',   // string;
-        path:    '/home',       // string;
-        secure:   true,         // boolean;
-        httpOnly: false,        // boolean;
-        sameSite: true,         // boolean | 'Lax' | 'None' | 'Strict';        
-    }
-})
-```
-
-### Response Status
-It's possible to control the response status via `status` function that is available in `useResponse()`
-
-```js
-import { useResponse } from '@wooksjs/event-http'
-app.get('test', async () => {
-    const { status } = useResponse()
-
-    // use function calls:
-    status(201) // sets status 201 for the response
-
-    console.log(status()) // when called with no argument returns the status
-
-    // also possible to use value:
-    // status.value = 201
-    // console.log(status.value)
-
-    return 'response with status 201'
-})
-```
-
-### Cache-Control
-`useSetCacheControl` function provides helpers for headers responsible for cache control
-
-```js
-import { useSetCacheControl } from '@wooksjs/event-http'
-app.get('static/*', () => {
-    const { 
-        setAge,             // sets Age (v: number | TProstoTimeMultiString) => void
-        setExpires,         // sets Expires (v: Date | string | number) => void
-        setPragmaNoCache,   // sets Pragma: no-cache (v: boolean) => void
-        setCacheControl,    // sets Cache-Control (data: TCacheControl) => void
-    } = useSetCacheControl()
-
-    setAge('2h 15m')
-    setExpires('2022-05-05')
-    setCacheControl({
-        mustRevalidate: true,
-        noCache: false,
-        noStore: false,
-        noTransform: true,
-        public: true,
-        private: 'field',
-        proxyRevalidate: true,
-        maxAge: '3h 30m 12s',
-        sMaxage: '2h 27m 54s',
-    })
-})
-```
-
-### Proxy Requests
-[More details here](https://github.com/wooksjs/proxy#readme)
-
-### Serve File
-[More details here](https://github.com/wooksjs/serve-file#readme)
-
-## Create you own hooks
-
-As an example we'll create a composable that resolves user profile
-
-```ts
-import { useAuthorization, useHttpContext } from '@wooksjs/event-http'
-
-interface TUser {
-    username: string
-    age: number
-    // ...
-}
-
-export function useUserProfile() {
-    // 1. get custom-typed context
-    const { store } = useHttpContext<{ user: TUser }>()
-    const user = store('user')
-
-    // 2. in this example will use basic credentials approach to get user name
-    const { basicCredentials } = useAuthorization()
-
-    // 3. get user name
-    const username = basicCredentials()?.username
-
-    // 4. user data async loader
-    async function userProfile() {
-        // first check if user data was already cached
-        // for this request
-        if (!user.value) {
-            // no user data cached yet, try to read user
-            // and return the result
-            user.value = await readUser()
-        }
-        // return user profile from cache
-        return user.value
-    }
-
-    // abstract readUser function
-    function readUser(): Promise<TUser> {
-        // return db.readUser(username)
-    }    
-
-    return {
-        username, // we have user name syncronously
-        userProfile, // and userProfile as (() => Promise<TUser>)
-    }
-}
-
-// example of usage of our useUserProfile
-app.get('/user', async () => {
-    const { username, userProfile } = useUserProfile()
-    console.log('username =', username)
-    const data = await userProfile()
-    return { user: data }
-})
-```
-
-Example of custom set header hook
-
-```ts
-import { useSetHeaders } from '@wooksjs/event-http'
-import { attachHook } from '@wooksjs/event-core'
-
-function useHeaderHook(name: string) {
-    const { setHeader, headers } = useSetHeaders()
-
-    return attachHook({
-        name,
-        type: 'header',
-    }, {
-        get: () => headers()[name] as string,
-        set: (value: string | number) => setHeader(name, value),
-    })
-}
-
-// usage
-
-app.get('/test', () => {
-    const myHeader = useHeaderHook('x-my-header')
-    myHeader.value = 'header value'
-    // *Please note that useSetHeader('x-my-header') will work similarly*
-    return 'ok'
-})
-
-// result:
-// 200
-// headers:
-// x-my-header: header value
-```
-
-## Adapter Documentation
-
-The next paragraph is for those who wants to create threir own adapter and get more control over the wooks.
-
-### Create a new wooks context
-
-Wooks context is a special object that stores:
-1. **instance of request** - is used to get data from request
-2. **instance of response** - is used to send a response
-3. **parsed route params** - usually Web App frameworks put it to `req` (`req.params`)
-4. **cache store** - is used to cache alread computed values, e.g. parsed body, parsed cookies, ..., in order to avoid multiple parsing/computetaion of the same entities.
-
-When request is generated by the client a new Wooks context must be created.
-
-`const {restoreCtx, clearCtx} = createHttpContext({ req, res })`
-
-```ts
-import { createHttpContext } from '@wooksjs/event-http'
-
-function requestHandler(req, res) {
-    const {
-        // restoreCtx hook helps to restore wooks context
-        // after any async operatuon
-        restoreCtx,
-
-        // clearCtx hook helps to clear wooks context
-        // when the request is already processed
-        clearCtx,
-
-        // store hook to access wooks store of the current ctx
-        store,
-    } = createHttpContext({
-        // request instance
-        req,
-        // response instance
-        res,
-    })
-
-    // if req already contains parsed params (req.params)
-    // then those will be picked up automatically
-    // unless you overwrite it here
-    store('routeParams').value = { name: 'value' }
-}
-
-```
-
-### Create a responder
-
-Responder is a function that takes any output of the request handler and transforms it into http response, processing headers, cookies, formats etc.
-
-`const {createResponse, respond} = createWooksResponder()`
-
-```ts
-import { createWooksResponder, createHttpContext } from '@wooksjs/event-http'
-
-const {createResponse, respond} = createWooksResponder(
-    /*renderer, // (optional) instance of TWooksResponseRenderer*/
-    /*errorRenderer, // (optional) instance of TWooksResponseRenderer*/
-)
-
-async function requestHandler(req, res) {
-    // 1. create wooks context
-    const {restoreCtx, clearCtx} = createHttpContext({ req, res })
-    // 2. process request based on routers/handlers and get the output
-    const response = await createHttpContext()
-    // 3. restore wooks context
-    restoreCtx()
-    // 4. respond
-    respond(response)
-    // 5. clear wooks context
-    clearCtx()
-}
-
-async function processHandlers() {
-    // routing, processing, handling, ...
-}
-
-```
-
-### Restore Context
-
-There is one more way to get `restoreCtx` hook besides the one you get when `createHttpContext`
-
-`const { restoreCtx, clearCtx } = useHttpContext()`
-
-```ts
-import { useHttpContext } from '@wooksjs/event-http'
-
-async function someHandler() {
-    const { restoreCtx, clearCtx } = useHttpContext()
-    await ... // some async operations
-    restoreCtx()
-    // here the wooks context is back
-}
-```
+To check out docs, visit [wooksjs.org](https://wooksjs.org/).

package/dist/index.cjs

@@ -464,7 +464,7 @@ function __asyncValues(o) {
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 }
 
-class BaseWooksResponseRenderer {
+class BaseHttpResponseRenderer {
     render(response) {
         if (typeof response.body === 'string' || typeof response.body === 'boolean' || typeof response.body === 'number') {
             if (!response.getContentType())
@@ -625,8 +625,8 @@ const defaultStatus = {
     PATCH: exports.EHttpStatusCode.Accepted,
     DELETE: exports.EHttpStatusCode.Accepted,
 };
-const baseRenderer = new BaseWooksResponseRenderer();
-class BaseWooksResponse {
+const baseRenderer = new BaseHttpResponseRenderer();
+class BaseHttpResponse {
     constructor(renderer = baseRenderer) {
         this.renderer = renderer;
         this._status = 0;
@@ -803,7 +803,7 @@ const preStyles = 'font-family: monospace;'
     + 'border-radius: 8px;'
     + 'background-color: #494949;'
     + 'box-shadow: 0px 0px 3px 2px rgb(255 255 255 / 20%);';
-class WooksErrorRenderer extends BaseWooksResponseRenderer {
+class HttpErrorRenderer extends BaseHttpResponseRenderer {
     renderHtml(response) {
         const data = response.body || {};
         response.setContentType('text/html');
@@ -812,7 +812,7 @@ class WooksErrorRenderer extends BaseWooksResponseRenderer {
             `<head><title>${data.statusCode} ${httpStatusCodes[data.statusCode]}</title></head>` +
             `<body><center><h1>${data.statusCode} ${httpStatusCodes[data.statusCode]}</h1></center>` +
             `<center><h4>${data.message}</h1></center><hr color="#666">` +
-            `<center style="color: #666;"> Wooks v${"0.2.8"} </center>` +
+            `<center style="color: #666;"> Wooks v${"0.2.10"} </center>` +
             `${keys.length ? `<pre style="${preStyles}">${JSON.stringify(Object.assign(Object.assign({}, data), { statusCode: undefined, message: undefined, error: undefined }), null, '  ')}</pre>` : ''}` +
             '</body></html>';
     }
@@ -877,15 +877,15 @@ class HttpError extends Error {
 
 function createWooksResponder(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-renderer = new BaseWooksResponseRenderer(), 
+renderer = new BaseHttpResponseRenderer(), 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-errorRenderer = new WooksErrorRenderer()) {
+errorRenderer = new HttpErrorRenderer()) {
     function createResponse(data) {
         const { hasResponded } = useResponse();
         if (hasResponded())
             return null;
         if (data instanceof Error) {
-            const r = new BaseWooksResponse(errorRenderer);
+            const r = new BaseHttpResponse(errorRenderer);
             let httpError;
             if (data instanceof HttpError) {
                 httpError = data;
@@ -896,11 +896,11 @@ errorRenderer = new WooksErrorRenderer()) {
             r.setBody(httpError.body);
             return r;
         }
-        else if (data instanceof BaseWooksResponse) {
+        else if (data instanceof BaseHttpResponse) {
             return data;
         }
         else {
-            return new BaseWooksResponse(renderer).setBody(data);
+            return new BaseHttpResponse(renderer).setBody(data);
         }
     }
     return {
@@ -1026,15 +1026,16 @@ function createHttpApp(opts, wooks) {
     return new WooksHttp(opts, wooks);
 }
 
-exports.BaseWooksResponse = BaseWooksResponse;
-exports.BaseWooksResponseRenderer = BaseWooksResponseRenderer;
+exports.BaseHttpResponse = BaseHttpResponse;
+exports.BaseHttpResponseRenderer = BaseHttpResponseRenderer;
 exports.HttpError = HttpError;
-exports.WooksErrorRenderer = WooksErrorRenderer;
+exports.HttpErrorRenderer = HttpErrorRenderer;
 exports.WooksHttp = WooksHttp;
 exports.WooksURLSearchParams = WooksURLSearchParams;
 exports.createHttpApp = createHttpApp;
 exports.createHttpContext = createHttpContext;
 exports.createWooksResponder = createWooksResponder;
+exports.httpStatusCodes = httpStatusCodes;
 exports.renderCacheControl = renderCacheControl;
 exports.useAccept = useAccept;
 exports.useAuthorization = useAuthorization;

package/dist/index.d.ts

@@ -13,9 +13,9 @@ import { URLSearchParams as URLSearchParams_2 } from 'url';
 import { Wooks } from 'wooks';
 import { WooksAdapterBase } from 'wooks';
 
-export declare class BaseWooksResponse<BodyType = unknown> {
-    protected renderer: BaseWooksResponseRenderer;
-    constructor(renderer?: BaseWooksResponseRenderer);
+export declare class BaseHttpResponse<BodyType = unknown> {
+    protected renderer: BaseHttpResponseRenderer;
+    constructor(renderer?: BaseHttpResponseRenderer);
     protected _status: EHttpStatusCode;
     protected _body?: BodyType;
     protected _headers: Record<string, string | string[]>;
@@ -39,8 +39,8 @@ export declare class BaseWooksResponse<BodyType = unknown> {
     respond(): Promise<unknown>;
 }
 
-export declare class BaseWooksResponseRenderer<T = unknown> implements TWooksResponseRenderer<T> {
-    render(response: BaseWooksResponse<T>): string | Uint8Array;
+export declare class BaseHttpResponseRenderer<T = unknown> implements TWooksResponseRenderer<T> {
+    render(response: BaseHttpResponse<T>): string | Uint8Array;
 }
 
 export declare function createHttpApp(opts?: TWooksHttpOptions, wooks?: Wooks | WooksAdapterBase): WooksHttp;
@@ -68,7 +68,7 @@ export declare function createHttpContext(data: THttpEventData): {
 };
 
 export declare function createWooksResponder(renderer?: TWooksResponseRenderer<any>, errorRenderer?: TWooksResponseRenderer<any>): {
-    createResponse: <T = unknown>(data: T) => BaseWooksResponse<TWooksErrorBodyExt | T> | null;
+    createResponse: <T = unknown>(data: T) => BaseHttpResponse<TWooksErrorBodyExt | T> | null;
     respond: (data: unknown) => Promise<unknown> | undefined;
 };
 
@@ -143,11 +143,84 @@ export declare class HttpError<T extends TWooksErrorBody = TWooksErrorBody> exte
     protected _body: string | T;
     constructor(code?: THttpErrorCodes, _body?: string | T);
     get body(): TWooksErrorBodyExt;
-    protected renderer?: WooksErrorRenderer;
-    attachRenderer(renderer: WooksErrorRenderer): void;
-    getRenderer(): WooksErrorRenderer | undefined;
+    protected renderer?: HttpErrorRenderer;
+    attachRenderer(renderer: HttpErrorRenderer): void;
+    getRenderer(): HttpErrorRenderer | undefined;
 }
 
+export declare class HttpErrorRenderer extends BaseHttpResponseRenderer<TWooksErrorBodyExt> {
+    renderHtml(response: BaseHttpResponse<TWooksErrorBodyExt>): string;
+    renderText(response: BaseHttpResponse<TWooksErrorBodyExt>): string;
+    renderJson(response: BaseHttpResponse<TWooksErrorBodyExt>): string;
+    render(response: BaseHttpResponse<TWooksErrorBodyExt>): string;
+}
+
+export declare const httpStatusCodes: {
+    100: string;
+    101: string;
+    102: string;
+    103: string;
+    200: string;
+    201: string;
+    202: string;
+    203: string;
+    204: string;
+    205: string;
+    206: string;
+    207: string;
+    208: string;
+    226: string;
+    300: string;
+    301: string;
+    302: string;
+    303: string;
+    304: string;
+    305: string;
+    306: string;
+    307: string;
+    308: string;
+    400: string;
+    401: string;
+    402: string;
+    403: string;
+    404: string;
+    405: string;
+    406: string;
+    407: string;
+    408: string;
+    409: string;
+    410: string;
+    411: string;
+    412: string;
+    413: string;
+    414: string;
+    415: string;
+    416: string;
+    417: string;
+    418: string;
+    421: string;
+    422: string;
+    423: string;
+    424: string;
+    425: string;
+    426: string;
+    428: string;
+    429: string;
+    431: string;
+    451: string;
+    500: string;
+    501: string;
+    502: string;
+    503: string;
+    504: string;
+    505: string;
+    506: string;
+    507: string;
+    508: string;
+    510: string;
+    511: string;
+};
+
 export declare function renderCacheControl(data: TCacheControl): string;
 
 export declare type TAuthCache = {
@@ -273,7 +346,7 @@ export declare interface TWooksHttpOptions {
 }
 
 export declare interface TWooksResponseRenderer<T = unknown> {
-    render: (response: BaseWooksResponse<T>) => string | Uint8Array;
+    render: (response: BaseHttpResponse<T>) => string | Uint8Array;
 }
 
 export declare function useAccept(): {
@@ -405,13 +478,6 @@ export declare function useStatus(): {
     isDefined: boolean;
 };
 
-export declare class WooksErrorRenderer extends BaseWooksResponseRenderer<TWooksErrorBodyExt> {
-    renderHtml(response: BaseWooksResponse<TWooksErrorBodyExt>): string;
-    renderText(response: BaseWooksResponse<TWooksErrorBodyExt>): string;
-    renderJson(response: BaseWooksResponse<TWooksErrorBodyExt>): string;
-    render(response: BaseWooksResponse<TWooksErrorBodyExt>): string;
-}
-
 export declare class WooksHttp extends WooksAdapterBase {
     protected opts?: TWooksHttpOptions | undefined;
     constructor(opts?: TWooksHttpOptions | undefined, wooks?: Wooks | WooksAdapterBase);
@@ -429,7 +495,7 @@ export declare class WooksHttp extends WooksAdapterBase {
     getServer(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | undefined;
     attachServer(server?: Server): void;
     protected responder: {
-        createResponse: <T = unknown>(data: T) => BaseWooksResponse<T | TWooksErrorBodyExt> | null;
+        createResponse: <T = unknown>(data: T) => BaseHttpResponse<T | TWooksErrorBodyExt> | null;
         respond: (data: unknown) => Promise<unknown> | undefined;
     };
     protected respond(data: unknown): void;

package/dist/index.mjs

@@ -462,7 +462,7 @@ function __asyncValues(o) {
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 }
 
-class BaseWooksResponseRenderer {
+class BaseHttpResponseRenderer {
     render(response) {
         if (typeof response.body === 'string' || typeof response.body === 'boolean' || typeof response.body === 'number') {
             if (!response.getContentType())
@@ -623,8 +623,8 @@ const defaultStatus = {
     PATCH: EHttpStatusCode.Accepted,
     DELETE: EHttpStatusCode.Accepted,
 };
-const baseRenderer = new BaseWooksResponseRenderer();
-class BaseWooksResponse {
+const baseRenderer = new BaseHttpResponseRenderer();
+class BaseHttpResponse {
     constructor(renderer = baseRenderer) {
         this.renderer = renderer;
         this._status = 0;
@@ -801,7 +801,7 @@ const preStyles = 'font-family: monospace;'
     + 'border-radius: 8px;'
     + 'background-color: #494949;'
     + 'box-shadow: 0px 0px 3px 2px rgb(255 255 255 / 20%);';
-class WooksErrorRenderer extends BaseWooksResponseRenderer {
+class HttpErrorRenderer extends BaseHttpResponseRenderer {
     renderHtml(response) {
         const data = response.body || {};
         response.setContentType('text/html');
@@ -810,7 +810,7 @@ class WooksErrorRenderer extends BaseWooksResponseRenderer {
             `<head><title>${data.statusCode} ${httpStatusCodes[data.statusCode]}</title></head>` +
             `<body><center><h1>${data.statusCode} ${httpStatusCodes[data.statusCode]}</h1></center>` +
             `<center><h4>${data.message}</h1></center><hr color="#666">` +
-            `<center style="color: #666;"> Wooks v${"0.2.8"} </center>` +
+            `<center style="color: #666;"> Wooks v${"0.2.10"} </center>` +
             `${keys.length ? `<pre style="${preStyles}">${JSON.stringify(Object.assign(Object.assign({}, data), { statusCode: undefined, message: undefined, error: undefined }), null, '  ')}</pre>` : ''}` +
             '</body></html>';
     }
@@ -875,15 +875,15 @@ class HttpError extends Error {
 
 function createWooksResponder(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-renderer = new BaseWooksResponseRenderer(), 
+renderer = new BaseHttpResponseRenderer(), 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-errorRenderer = new WooksErrorRenderer()) {
+errorRenderer = new HttpErrorRenderer()) {
     function createResponse(data) {
         const { hasResponded } = useResponse();
         if (hasResponded())
             return null;
         if (data instanceof Error) {
-            const r = new BaseWooksResponse(errorRenderer);
+            const r = new BaseHttpResponse(errorRenderer);
             let httpError;
             if (data instanceof HttpError) {
                 httpError = data;
@@ -894,11 +894,11 @@ errorRenderer = new WooksErrorRenderer()) {
             r.setBody(httpError.body);
             return r;
         }
-        else if (data instanceof BaseWooksResponse) {
+        else if (data instanceof BaseHttpResponse) {
             return data;
         }
         else {
-            return new BaseWooksResponse(renderer).setBody(data);
+            return new BaseHttpResponse(renderer).setBody(data);
         }
     }
     return {
@@ -1024,4 +1024,4 @@ function createHttpApp(opts, wooks) {
     return new WooksHttp(opts, wooks);
 }
 
-export { BaseWooksResponse, BaseWooksResponseRenderer, EHttpStatusCode, HttpError, WooksErrorRenderer, WooksHttp, WooksURLSearchParams, createHttpApp, createHttpContext, createWooksResponder, renderCacheControl, useAccept, useAuthorization, useCookies, useHeaders, useHttpContext, useRequest, useResponse, useSearchParams, useSetCacheControl, useSetCookie, useSetCookies, useSetHeader, useSetHeaders, useStatus };
+export { BaseHttpResponse, BaseHttpResponseRenderer, EHttpStatusCode, HttpError, HttpErrorRenderer, WooksHttp, WooksURLSearchParams, createHttpApp, createHttpContext, createWooksResponder, httpStatusCodes, renderCacheControl, useAccept, useAuthorization, useCookies, useHeaders, useHttpContext, useRequest, useResponse, useSearchParams, useSetCacheControl, useSetCookie, useSetCookies, useSetHeader, useSetHeaders, useStatus };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wooksjs/event-http",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "@wooksjs/event-http",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -31,8 +31,9 @@
     "url": "https://github.com/wooksjs/wooksjs/issues"
   },
   "peerDependencies": {
-    "wooks": "0.2.8",
-    "@wooksjs/event-core": "0.2.8"
+    "wooks": "0.2.10",
+    "@prostojs/router": "^0.0.16",
+    "@wooksjs/event-core": "0.2.10"
   },
   "homepage": "https://github.com/wooksjs/wooksjs/tree/main/packages/event-http#readme"
 }