wooks 0.0.1-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 prostojs
+
+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,522 @@
+# Wooks
+
+**!!! This is work-in-progress library, breaking changes are expected !!!**
+
+Wooks is a Web Application Framework with hooks.
+
+As an alternative for `express` and `fastify`, `wooks` brings the whole different approach for processing http requests.
+It utilizes such a technique as you can see in React Hooks or Vue Composables. It has only a dependency on [@prostojs/router](https://github.com/prostojs/router) (an alternative to `find-my-way` used by `fastify`) which is a very fast (see benchmarks [here](https://github.com/prostojs/router-benchmark)) and robust URI router. 
+
+`wooks` supports cookie parsing and serving files out of the box with no impact on performance.
+
+The main ideas behind wooks are:
+
+1. Never mutate request object (`req`). Accumulate a request context in a separate object(s) instead;
+2. Never parse anything (cookies, body) before it is really requested by the request handler;
+3. Get rid of complex predefined data objects containing everything (cookies, headers, body, parsed body etc.) and use composable functions (hooks) instead;
+4. Get rid of tons of dependencies (middlewares) and implement everything that is needed for web app in a simple way.
+
+
+## Quick Start
+
+```js
+const { Wooks } = require('wooks')
+
+const app = new Wooks()
+
+app.get('test', () => {
+    return { message: 'hello world!' }
+})
+
+app.listen(3000, () => { console.log('Wooks Server is up on port 3000') })
+```
+
+## Install
+
+`npm install wooks`
+
+## Routes
+
+It supports static, parametric and wildcard routes with regex expressions (see details in [@prostojs/router](https://github.com/prostojs/router))
+
+Static route:
+```js
+app.get('static/route', () => {})
+```
+
+Parametric route:
+```js
+app.get('parametric/:param1/:param2/...', () => {})
+```
+
+Wildcard route:
+```js
+app.get('wildcard/*', () => {})
+```
+
+Complex wildcard route (use as many asterisks as you need and even specify a static parts after them):
+```js
+app.get('wildcard/start-*/*.html', () => {})
+```
+
+
+## URL Parameters
+
+To get access to URL parameters use composable function `useRouteParams`
+
+```js
+import { useRouteParams } from 'wooks'
+app.get('parametric/:param1/:param2/...', () => {
+    const { routeParams, getRouteParam } = useRouteParams()
+    // presume we had a request on `/parametric/value1/value2`
+    console.log('param1=' + getRouteParam('param1'))
+    // prints "param1=value1"
+    console.log('param2=' + getRouteParam('param2'))
+    // prints "param2=value2"
+    console.log(routeParams)
+    // prints {
+    //   param1: "value1",
+    //   param2: "value2" 
+    // }
+})
+```
+
+## Query Parameters
+
+To get access to Query parameters use composable function `useSearchParams`
+
+```js
+import { useSearchParams } from 'wooks'
+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 'wooks'
+app.get('test', () => {
+    const { rawRequest } = useRequest()
+})
+```
+
+### Request Method, Headers, ...
+
+`useRequest` provides some more shortcuts for useful data
+
+```js
+import { useRequest } from 'wooks'
+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 'wooks'
+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 Body Parser
+
+Function `useBody` provides utilities for getting decoded and parsed body.
+
+Body parser supports json, string, multipart/form-data and application/x-www-form-urlencoded content-types.
+
+Body parser does not parse every request's body. The parsing happens only when you call `parseBody` function.
+
+The request handler is invoked even before the request body was sent to the server.
+
+```js
+import { useBody } from 'wooks'
+app.post('test', async () => {
+    const {
+        isJson, // checks if content-type is "application/json" : () => boolean;
+        isHtml, // checks if content-type is "text/html" : () => boolean;
+        isXml, // checks if content-type is "application/xml" : () => boolean;
+        isText, // checks if content-type is "text/plain" : () => boolean;
+        isBinary, // checks if content-type is binary : () => boolean;
+        isFormData, // checks if content-type is "multipart/form-data" : () => boolean;
+        isUrlencoded, // checks if content-type is "application/x-www-form-urlencoded" : () => boolean;
+        isCompressed, // checks content-encoding : () => boolean | undefined;
+        contentEncodings, // returns an array of encodings : () => string[];
+        parseBody, // parses body according to content-type : <T = unknown>() => Promise<T>;
+        rawBody, // returns raw body Buffer : () => Promise<Buffer>;
+    } = useBody()
+
+    // the handler got the control, but the body isn't loaded yet
+    //...
+
+    console.log(await parseBody())
+
+    // after `await parseBody()` the body was loaded and parsed
+    // ...
+})
+```
+
+### Request Authorization
+
+`useAuthorization` function provides useful helpers for auth-headers:
+
+```js
+import { useAuthorization } from 'wooks'
+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
+    }
+})
+```
+
+## 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)
+
+**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 'wooks'
+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 'wooks'
+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 'wooks'
+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" }'
+})
+```
+
+### Response Cookies (Set-Cookie)
+
+A function `useSetCookies` provides variety of set-cookie helpers:
+
+```js
+import { useSetCookies } from 'wooks'
+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', {
+        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 'wooks'
+app.get('test', async () => {
+    const { status } = useResponse()
+    status(201) // sets status 201 for the response
+    console.log(status()) // when called with no argument returns the status
+    return 'response with status 201'
+})
+```
+
+### Cache-Control
+
+`useSetCacheControl` function provides helpers for headers responsible for cache control
+
+```js
+import { useSetCacheControl } from 'wooks'
+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',
+    })
+})
+```
+
+### Serve File (Serve-Static)
+
+Function `serveFile` returns a readable stream and prepares all the neccessary response headers (like content-length, content-type etc).
+
+It can handle etag and range as well.
+
+```js
+serveFile(filePath, options)
+```
+
+**serveFile options**
+```ts
+{
+    // Any header to add
+    headers?: Record<string, string>
+
+    // Cache-Control header
+    cacheControl?: TCacheControl
+
+    // Expires header
+    expires?: Date | string | number
+
+    // when true a header "Pragma: no-cache" will be added
+    pragmaNoCache?: boolean
+
+    // the base directory path
+    baseDir?: string
+
+    // default extension will be added to the filePath
+    defaultExt?: string
+
+    // when true lists files in directory
+    listDirectory?: boolean
+    
+    // put 'index.html'
+    // to automatically serve it from the folder    
+    index?: string              
+}
+```
+
+Built-in file server example:
+
+```js
+import { serveFile, useRouteParams } from 'wooks'
+app.get('static/*', () => {
+    const { getRouteParam } = useRouteParams()
+    return serveFile(getRouteParam('*'), { cacheControl: { maxAge: '10m' } })
+})
+```
+
+`cacheControl` here is the same object as used in `useSetCacheControl().setCacheControl({ ... })`
+
+## Error Handling
+
+All the exeptions occured in handler are cought by the framework and interpreted as Server Error 500.
+
+
+```js
+app.get('error', () => {
+    throw new Error('Some Error')
+    // A call of this endpoint will result in
+    // 500 Internal Server Error
+    // "Some Error"
+})
+```
+
+By default the Error Handler renders the response according to the `Accept` request header:
+- if it accepts 'application/json' then the response will be in JSON format
+- else if it accepts 'text/html' then the response will be in HTML format
+- else if it accepts 'text/plain' then the response will be rendered in a plain text
+- else the response will be in JSON format anyways
+
+It's possible to return your own error:
+
+```js
+import { WooksError } from 'wooks'
+app.get('error', () => {
+    throw new WooksError('429', 'My Description')
+    // A call of this endpoint will result in
+    // 429 Too Many Requests
+    // "My Description"
+})
+```
+
+In this case if you have an alternative (fallback) handler for the same route the error may not occure, the next handler will be called instead.
+
+As an alternative you may not throw the error but return its instance:
+
+```js
+import { WooksError } from 'wooks'
+app.get('error', () => {
+    return new WooksError('429', 'My Description')
+    // A call of this endpoint will result in
+    // 429 Too Many Requests
+    // "My Description"
+})
+```
+
+In this case if you have an alternative (fallback) handler for the same route the error will occure anyways as you explicitly return its instance.
+
+## Alternative (Fallback) Handler
+
+It's possible to assign several handlers for the same route. Every next handler will work as a fallback for the previous one.
+
+The fallback handler is called only when exception is thrown out of the previous handler.
+
+If the previous handler returns an Error Instance then the fallback handler won't be called.
+
+For example you serve files, but for some 'not found' files you want to do something else:
+
+```js
+import { Wooks, serveFile, useRouteParams } from 'wooks'
+const app = new Wooks()
+
+app.get('static/*', () => {
+    const { getRouteParam } = useRouteParams()
+    // serveFile will throw 404 error if the file is not found
+    return serveFile(getRouteParam('*'), { maxAge: '10m' })
+})
+
+app.get('static/*', () => {
+    // this handler will be called every time the file is not found
+    return 'Here\'s my fallback response'
+})
+
+app.listen(3000)
+```
+
+In order to prevent the fallback to be invoked you must return an Error Instance explicitly:
+
+```js
+import { Wooks, serveFile, useRouteParams } from 'wooks'
+const app = new Wooks()
+
+app.get('static/*', () => {
+    const { getRouteParam } = useRouteParams()
+    try {
+        return serveFile(getRouteParam('*'), { maxAge: '10m' })
+    }
+    catch (e) {
+        // now we catch error and return it explicitly
+        return e
+    }
+})
+
+app.get('static/*', () => {
+    // this handler will be never called now
+    return 'Here\'s my fallback response which is never (ever) called'
+})
+
+app.listen(3000)
+```

package/dist/src/composables/body.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { TBodyCompressor } from '../utils/body-compressor';
+export declare function useBody(): {
+    isJson: () => boolean;
+    isHtml: () => boolean;
+    isXml: () => boolean;
+    isText: () => boolean;
+    isBinary: () => boolean;
+    isFormData: () => boolean;
+    isUrlencoded: () => boolean;
+    isCompressed: () => boolean | undefined;
+    contentEncodings: () => string[];
+    parseBody: <T = unknown>() => Promise<T>;
+    rawBody: () => Promise<Buffer>;
+};
+export declare function registerBodyCompressor(name: string, compressor: TBodyCompressor): void;
+//# sourceMappingURL=body.d.ts.map

package/dist/src/composables/body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"body.d.ts","sourceRoot":"","sources":["../../../src/composables/body.ts"],"names":[],"mappings":";AAIA,OAAO,EAAe,eAAe,EAAkB,MAAM,0BAA0B,CAAA;AAkBvF,wBAAgB,OAAO;;;;;;;;;4BAqEU,MAAM,EAAE;;;EAmGxC;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,QAK/E"}

package/dist/src/composables/cookies.d.ts

@@ -0,0 +1,13 @@
+import { TCookieAttributes } from '../utils/set-cookie';
+export declare type TCookiesCache = Record<string, string | null>;
+export declare function useCookies(): {
+    rawCookies: string | undefined;
+    getCookie: (name: string) => string | null;
+};
+export declare function useSetCookies(): {
+    setCookie: (name: string, value: string, attrs?: Partial<TCookieAttributes>) => void;
+    removeCookie: (name: string) => void;
+    clearCookies: () => void;
+    cookies: () => string[];
+};
+//# sourceMappingURL=cookies.d.ts.map

package/dist/src/composables/cookies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cookies.d.ts","sourceRoot":"","sources":["../../../src/composables/cookies.ts"],"names":[],"mappings":"AAGA,OAAO,EAAgB,iBAAiB,EAAkB,MAAM,qBAAqB,CAAA;AAErF,oBAAY,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;AAGzD,wBAAgB,UAAU;;sBAIG,MAAM;EAgBlC;AAED,wBAAgB,aAAa;sBAGA,MAAM,SAAS,MAAM,UAAU,QAAQ,iBAAiB,CAAC;yBAWtD,MAAM;;mBAJd,MAAM,EAAE;EAkB/B"}

package/dist/src/composables/core-test.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { TProstoParamsType } from '@prostojs/router';
+import { TCookiesCache } from './cookies';
+import { TAuthCache } from './header-authorization';
+export interface TTestHttpContext {
+    params?: TProstoParamsType;
+    url: string;
+    headers?: Record<string, string>;
+    method?: string;
+    cachedContext?: {
+        cookies?: TCookiesCache;
+        authorization?: TAuthCache;
+        body?: unknown;
+        rawBody?: string | Buffer | Promise<Buffer>;
+        [name: string | symbol]: unknown;
+    };
+}
+export declare function setTestHttpContext(options: TTestHttpContext): void;
+//# sourceMappingURL=core-test.d.ts.map

package/dist/src/composables/core-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-test.d.ts","sourceRoot":"","sources":["../../../src/composables/core-test.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAIzC,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAEnD,MAAM,WAAW,gBAAgB;IAC7B,MAAM,CAAC,EAAE,iBAAiB,CAAA;IAC1B,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,aAAa,CAAC,EAAE;QACZ,OAAO,CAAC,EAAE,aAAa,CAAA;QACvB,aAAa,CAAC,EAAE,UAAU,CAAA;QAC1B,IAAI,CAAC,EAAE,OAAO,CAAA;QACd,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;QAC3C,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;KACnC,CAAA;CACJ;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,QA2B3D"}

package/dist/src/composables/core.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { TProstoParamsType } from '@prostojs/router';
+import { IncomingMessage, ServerResponse } from 'http';
+export interface TCurrentWooksContext {
+    req: IncomingMessage;
+    res: ServerResponse;
+    params: TProstoParamsType;
+    customContext: TWooksCustomContext;
+}
+export declare type TWooksCustomContext = Record<string | symbol, unknown>;
+export declare function useCurrentWooksContext(): {
+    getCtx: () => TCurrentWooksContext;
+    restoreCtx: () => void;
+};
+export declare function clearCurrentWooksContext(): void;
+export declare function setCurrentWooksContext(req: IncomingMessage, res: ServerResponse, params: TProstoParamsType, customContext: TWooksCustomContext): void;
+export declare const innerCacheSymbols: {
+    searchParams: symbol;
+    cookies: symbol;
+    accept: symbol;
+    authorization: symbol;
+    setHeader: symbol;
+    setCookies: symbol;
+    status: symbol;
+    response: symbol;
+    request: symbol;
+};
+export declare function useCacheObject<T = unknown>(name: symbol | string): T;
+export declare function clearCacheObject(name: symbol | string): void;
+//# sourceMappingURL=core.d.ts.map

package/dist/src/composables/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../src/composables/core.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAA;AAGtD,MAAM,WAAW,oBAAoB;IACjC,GAAG,EAAE,eAAe,CAAA;IACpB,GAAG,EAAE,cAAc,CAAA;IACnB,MAAM,EAAE,iBAAiB,CAAA;IACzB,aAAa,EAAE,mBAAmB,CAAA;CACrC;AAID,oBAAY,mBAAmB,GAAG,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,CAAA;AAElE,wBAAgB,sBAAsB;;;EASrC;AAED,wBAAgB,wBAAwB,SAEvC;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,EAAE,MAAM,EAAE,iBAAiB,EAAE,aAAa,EAAE,mBAAmB,QAE9I;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;CAU7B,CAAA;AAED,wBAAgB,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,CAIpE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,QAkBrD"}

package/dist/src/composables/header-accept.d.ts

@@ -0,0 +1,9 @@
+export declare function useAccept(): {
+    accept: string | undefined;
+    accepts: (mime: string) => boolean;
+    acceptsJson: () => boolean;
+    acceptsXml: () => boolean;
+    acceptsText: () => boolean;
+    acceptsHtml: () => boolean;
+};
+//# sourceMappingURL=header-accept.d.ts.map

package/dist/src/composables/header-accept.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-accept.d.ts","sourceRoot":"","sources":["../../../src/composables/header-accept.ts"],"names":[],"mappings":"AAIA,wBAAgB,SAAS;;oBAGE,MAAM;;;;;EAchC"}

package/dist/src/composables/header-authorization.d.ts

@@ -0,0 +1,20 @@
+export declare type TAuthCache = {
+    type: string | null;
+    credentials: string | null;
+    basicCredentials: {
+        username: string;
+        password: string;
+    } | null;
+};
+export declare function useAuthorization(): {
+    authorization: string | undefined;
+    authType: () => string | null;
+    authRawCredentials: () => string | null;
+    isBasic: () => boolean;
+    isBearer: () => boolean;
+    basicCredentials: () => {
+        username: string;
+        password: string;
+    } | null;
+};
+//# sourceMappingURL=header-authorization.d.ts.map

package/dist/src/composables/header-authorization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-authorization.d.ts","sourceRoot":"","sources":["../../../src/composables/header-authorization.ts"],"names":[],"mappings":"AAGA,oBAAY,UAAU,GAAG;IACrB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,gBAAgB,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAClE,CAAA;AAED,wBAAgB,gBAAgB;;;;;;;;;;EA4C/B"}