@kerebron/extension-server-hono 0.4.26 → 0.4.27

package/esm/deps/jsr.io/@hono/hono/4.11.1/src/request.js

@@ -1,327 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { HTTPException } from './http-exception.js';
-import { GET_MATCH_RESULT } from './request/constants.js';
-import { parseBody } from './utils/body.js';
-import { decodeURIComponent_, getQueryParam, getQueryParams, tryDecode } from './utils/url.js';
-const tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
-export class HonoRequest {
-    /**
-     * `.raw` can get the raw Request object.
-     *
-     * @see {@link https://hono.dev/docs/api/request#raw}
-     *
-     * @example
-     * ```ts
-     * // For Cloudflare Workers
-     * app.post('/', async (c) => {
-     *   const metadata = c.req.raw.cf?.hostMetadata?
-     *   ...
-     * })
-     * ```
-     */
-    raw;
-    #validatedData; // Short name of validatedData
-    #matchResult;
-    routeIndex = 0;
-    /**
-     * `.path` can get the pathname of the request.
-     *
-     * @see {@link https://hono.dev/docs/api/request#path}
-     *
-     * @example
-     * ```ts
-     * app.get('/about/me', (c) => {
-     *   const pathname = c.req.path // `/about/me`
-     * })
-     * ```
-     */
-    path;
-    bodyCache = {};
-    constructor(request, path = '/', matchResult = [[]]) {
-        this.raw = request;
-        this.path = path;
-        this.#matchResult = matchResult;
-        this.#validatedData = {};
-    }
-    param(key) {
-        return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
-    }
-    #getDecodedParam(key) {
-        const paramKey = this.#matchResult[0][this.routeIndex][1][key];
-        const param = this.#getParamValue(paramKey);
-        return param && /\%/.test(param) ? tryDecodeURIComponent(param) : param;
-    }
-    #getAllDecodedParams() {
-        const decoded = {};
-        const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
-        for (const key of keys) {
-            const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
-            if (value !== undefined) {
-                decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
-            }
-        }
-        return decoded;
-    }
-    #getParamValue(paramKey) {
-        return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
-    }
-    query(key) {
-        return getQueryParam(this.url, key);
-    }
-    queries(key) {
-        return getQueryParams(this.url, key);
-    }
-    header(name) {
-        if (name) {
-            return this.raw.headers.get(name) ?? undefined;
-        }
-        const headerData = {};
-        this.raw.headers.forEach((value, key) => {
-            headerData[key] = value;
-        });
-        return headerData;
-    }
-    async parseBody(options) {
-        return (this.bodyCache.parsedBody ??= await parseBody(this, options));
-    }
-    #cachedBody = (key) => {
-        const { bodyCache, raw } = this;
-        const cachedBody = bodyCache[key];
-        if (cachedBody) {
-            return cachedBody;
-        }
-        const anyCachedKey = Object.keys(bodyCache)[0];
-        if (anyCachedKey) {
-            return bodyCache[anyCachedKey].then((body) => {
-                if (anyCachedKey === 'json') {
-                    body = JSON.stringify(body);
-                }
-                return new Response(body)[key]();
-            });
-        }
-        return (bodyCache[key] = raw[key]());
-    };
-    /**
-     * `.json()` can parse Request body of type `application/json`
-     *
-     * @see {@link https://hono.dev/docs/api/request#json}
-     *
-     * @example
-     * ```ts
-     * app.post('/entry', async (c) => {
-     *   const body = await c.req.json()
-     * })
-     * ```
-     */
-    json() {
-        return this.#cachedBody('text').then((text) => JSON.parse(text));
-    }
-    /**
-     * `.text()` can parse Request body of type `text/plain`
-     *
-     * @see {@link https://hono.dev/docs/api/request#text}
-     *
-     * @example
-     * ```ts
-     * app.post('/entry', async (c) => {
-     *   const body = await c.req.text()
-     * })
-     * ```
-     */
-    text() {
-        return this.#cachedBody('text');
-    }
-    /**
-     * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
-     *
-     * @see {@link https://hono.dev/docs/api/request#arraybuffer}
-     *
-     * @example
-     * ```ts
-     * app.post('/entry', async (c) => {
-     *   const body = await c.req.arrayBuffer()
-     * })
-     * ```
-     */
-    arrayBuffer() {
-        return this.#cachedBody('arrayBuffer');
-    }
-    /**
-     * Parses the request body as a `Blob`.
-     * @example
-     * ```ts
-     * app.post('/entry', async (c) => {
-     *   const body = await c.req.blob();
-     * });
-     * ```
-     * @see https://hono.dev/docs/api/request#blob
-     */
-    blob() {
-        return this.#cachedBody('blob');
-    }
-    /**
-     * Parses the request body as `FormData`.
-     * @example
-     * ```ts
-     * app.post('/entry', async (c) => {
-     *   const body = await c.req.formData();
-     * });
-     * ```
-     * @see https://hono.dev/docs/api/request#formdata
-     */
-    formData() {
-        return this.#cachedBody('formData');
-    }
-    /**
-     * Adds validated data to the request.
-     *
-     * @param target - The target of the validation.
-     * @param data - The validated data to add.
-     */
-    addValidatedData(target, data) {
-        this.#validatedData[target] = data;
-    }
-    valid(target) {
-        return this.#validatedData[target];
-    }
-    /**
-     * `.url()` can get the request url strings.
-     *
-     * @see {@link https://hono.dev/docs/api/request#url}
-     *
-     * @example
-     * ```ts
-     * app.get('/about/me', (c) => {
-     *   const url = c.req.url // `http://localhost:8787/about/me`
-     *   ...
-     * })
-     * ```
-     */
-    get url() {
-        return this.raw.url;
-    }
-    /**
-     * `.method()` can get the method name of the request.
-     *
-     * @see {@link https://hono.dev/docs/api/request#method}
-     *
-     * @example
-     * ```ts
-     * app.get('/about/me', (c) => {
-     *   const method = c.req.method // `GET`
-     * })
-     * ```
-     */
-    get method() {
-        return this.raw.method;
-    }
-    get [GET_MATCH_RESULT]() {
-        return this.#matchResult;
-    }
-    /**
-     * `.matchedRoutes()` can return a matched route in the handler
-     *
-     * @deprecated
-     *
-     * Use matchedRoutes helper defined in "hono/route" instead.
-     *
-     * @see {@link https://hono.dev/docs/api/request#matchedroutes}
-     *
-     * @example
-     * ```ts
-     * app.use('*', async function logger(c, next) {
-     *   await next()
-     *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
-     *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
-     *     console.log(
-     *       method,
-     *       ' ',
-     *       path,
-     *       ' '.repeat(Math.max(10 - path.length, 0)),
-     *       name,
-     *       i === c.req.routeIndex ? '<- respond from here' : ''
-     *     )
-     *   })
-     * })
-     * ```
-     */
-    get matchedRoutes() {
-        return this.#matchResult[0].map(([[, route]]) => route);
-    }
-    /**
-     * `routePath()` can retrieve the path registered within the handler
-     *
-     * @deprecated
-     *
-     * Use routePath helper defined in "hono/route" instead.
-     *
-     * @see {@link https://hono.dev/docs/api/request#routepath}
-     *
-     * @example
-     * ```ts
-     * app.get('/posts/:id', (c) => {
-     *   return c.json({ path: c.req.routePath })
-     * })
-     * ```
-     */
-    get routePath() {
-        return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
-    }
-}
-/**
- * Clones a HonoRequest's underlying raw Request object.
- *
- * This utility handles both consumed and unconsumed request bodies:
- * - If the request body hasn't been consumed, it uses the native `clone()` method
- * - If the request body has been consumed, it reconstructs a new Request using cached body data
- *
- * This is particularly useful when you need to:
- * - Process the same request body multiple times
- * - Pass requests to external services after validation
- *
- * @param req - The HonoRequest object to clone
- * @returns A Promise that resolves to a new Request object with the same properties
- * @throws {HTTPException} If the request body was consumed directly via `req.raw`
- *   without using HonoRequest methods (e.g., `req.json()`, `req.text()`), making it
- *   impossible to reconstruct the body from cache
- *
- * @example
- * ```ts
- * // Clone after consuming the body (e.g., after validation)
- * app.post('/forward',
- *   validator('json', (data) => data),
- *   async (c) => {
- *     const validated = c.req.valid('json')
- *     // Body has been consumed, but cloneRawRequest still works
- *     const clonedReq = await cloneRawRequest(c.req)
- *     return fetch('http://backend-service.com', clonedReq)
- *   }
- * )
- * ```
- */
-export const cloneRawRequest = async (req) => {
-    if (!req.raw.bodyUsed) {
-        return req.raw.clone();
-    }
-    const cacheKey = Object.keys(req.bodyCache)[0];
-    if (!cacheKey) {
-        throw new HTTPException(500, {
-            message: 'Cannot clone request: body was already consumed and not cached. Please use HonoRequest methods (e.g., req.json(), req.text()) instead of consuming req.raw directly.',
-        });
-    }
-    const requestInit = {
-        body: await req[cacheKey](),
-        cache: req.raw.cache,
-        credentials: req.raw.credentials,
-        headers: req.header(),
-        integrity: req.raw.integrity,
-        keepalive: req.raw.keepalive,
-        method: req.method,
-        mode: req.raw.mode,
-        redirect: req.raw.redirect,
-        referrer: req.raw.referrer,
-        referrerPolicy: req.raw.referrerPolicy,
-        signal: req.raw.signal,
-    };
-    return new Request(req.url, requestInit);
-};

package/esm/deps/jsr.io/@hono/hono/4.11.1/src/router.d.ts

@@ -1,98 +0,0 @@
-/**
- * @module
- * This module provides types definitions and variables for the routers.
- */
-/**
- * Constant representing all HTTP methods in uppercase.
- */
-export declare const METHOD_NAME_ALL: "ALL";
-/**
- * Constant representing all HTTP methods in lowercase.
- */
-export declare const METHOD_NAME_ALL_LOWERCASE: "all";
-/**
- * Array of supported HTTP methods.
- */
-export declare const METHODS: readonly ["get", "post", "put", "delete", "options", "patch"];
-/**
- * Error message indicating that a route cannot be added because the matcher is already built.
- */
-export declare const MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
-/**
- * Interface representing a router.
- *
- * @template T - The type of the handler.
- */
-export interface Router<T> {
-    /**
-     * The name of the router.
-     */
-    name: string;
-    /**
-     * Adds a route to the router.
-     *
-     * @param method - The HTTP method (e.g., 'get', 'post').
-     * @param path - The path for the route.
-     * @param handler - The handler for the route.
-     */
-    add(method: string, path: string, handler: T): void;
-    /**
-     * Matches a route based on the given method and path.
-     *
-     * @param method - The HTTP method (e.g., 'get', 'post').
-     * @param path - The path to match.
-     * @returns The result of the match.
-     */
-    match(method: string, path: string): Result<T>;
-}
-/**
- * Type representing a map of parameter indices.
- */
-export type ParamIndexMap = Record<string, number>;
-/**
- * Type representing a stash of parameters.
- */
-export type ParamStash = string[];
-/**
- * Type representing a map of parameters.
- */
-export type Params = Record<string, string>;
-/**
- * Type representing the result of a route match.
- *
- * The result can be in one of two formats:
- * 1. An array of handlers with their corresponding parameter index maps, followed by a parameter stash.
- * 2. An array of handlers with their corresponding parameter maps.
- *
- * Example:
- *
- * [[handler, paramIndexMap][], paramArray]
- * ```typescript
- * [
- *   [
- *     [middlewareA, {}],                     // '*'
- *     [funcA,       {'id': 0}],              // '/user/:id/*'
- *     [funcB,       {'id': 0, 'action': 1}], // '/user/:id/:action'
- *   ],
- *   ['123', 'abc']
- * ]
- * ```
- *
- * [[handler, params][]]
- * ```typescript
- * [
- *   [
- *     [middlewareA, {}],                             // '*'
- *     [funcA,       {'id': '123'}],                  // '/user/:id/*'
- *     [funcB,       {'id': '123', 'action': 'abc'}], // '/user/:id/:action'
- *   ]
- * ]
- * ```
- */
-export type Result<T> = [[T, ParamIndexMap][], ParamStash] | [[T, Params][]];
-/**
- * Error class representing an unsupported path error.
- */
-export declare class UnsupportedPathError extends Error {
-}
-//# sourceMappingURL=router.d.ts.map

package/esm/deps/jsr.io/@hono/hono/4.11.1/src/router.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@hono/hono/4.11.1/src/router.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe,EAAG,KAAc,CAAA;AAC7C;;GAEG;AACH,eAAO,MAAM,yBAAyB,EAAG,KAAc,CAAA;AACvD;;GAEG;AACH,eAAO,MAAM,OAAO,+DAAgE,CAAA;AACpF;;GAEG;AACH,eAAO,MAAM,gCAAgC,4DACc,CAAA;AAE3D;;;;GAIG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IAEZ;;;;;;OAMG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,CAAA;IAEnD;;;;;;OAMG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;CAC/C;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAClD;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,EAAE,CAAA;AACjC;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,EAAE,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,CAAA;AAE5E;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;CAAG"}

package/esm/deps/jsr.io/@hono/hono/4.11.1/src/router.js

@@ -1,25 +0,0 @@
-/**
- * @module
- * This module provides types definitions and variables for the routers.
- */
-/**
- * Constant representing all HTTP methods in uppercase.
- */
-export const METHOD_NAME_ALL = 'ALL';
-/**
- * Constant representing all HTTP methods in lowercase.
- */
-export const METHOD_NAME_ALL_LOWERCASE = 'all';
-/**
- * Array of supported HTTP methods.
- */
-export const METHODS = ['get', 'post', 'put', 'delete', 'options', 'patch'];
-/**
- * Error message indicating that a route cannot be added because the matcher is already built.
- */
-export const MESSAGE_MATCHER_IS_ALREADY_BUILT = 'Can not add a route since the matcher is already built.';
-/**
- * Error class representing an unsupported path error.
- */
-export class UnsupportedPathError extends Error {
-}