@rho-workspace/rho 0.5.2 → 0.5.3

package/node_modules/hono/dist/types/request.d.ts

@@ -1,326 +0,0 @@
-import { GET_MATCH_RESULT } from "./request/constants.js";
-import { Result } from "./router.js";
-import { CustomHeader, RequestHeader } from "./utils/headers.js";
-import { Simplify, UnionToIntersection } from "./utils/types.js";
-import { Input, InputToDataByTarget, ParamKeyToRecord, ParamKeys, RemoveQuestion, RouterRoute, ValidationTargets } from "./types.js";
-import { BodyData, ParseBodyOptions } from "./utils/body.js";
-//#region src/request.d.ts
-type Body = {
-  json: any;
-  text: string;
-  arrayBuffer: ArrayBuffer;
-  blob: Blob;
-  formData: FormData;
-};
-type BodyCache = Partial<Body>;
-export declare class HonoRequest<P extends string = '/', I extends Input['out'] = {}> {
-  
-  /**
-   * `.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: Request;
-  routeIndex: number;
-  /**
-   * `.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: string;
-  bodyCache: BodyCache;
-  constructor(request: Request, path?: string, matchResult?: Result<[unknown, RouterRoute]>);
-  /**
-   * `.req.param()` gets the path parameters.
-   *
-   * @see {@link https://hono.dev/docs/api/routing#path-parameter}
-   *
-   * @example
-   * ```ts
-   * const name = c.req.param('name')
-   * // or all parameters at once
-   * const { id, comment_id } = c.req.param()
-   * ```
-   */
-  param<P2 extends ParamKeys<P> = ParamKeys<P>>(key: string extends P ? never : P2 extends `${infer _}?` ? never : P2): string;
-  param<P2 extends RemoveQuestion<ParamKeys<P>> = RemoveQuestion<ParamKeys<P>>>(key: P2): string | undefined;
-  param(key: string): string | undefined;
-  param<P2 extends string = P>(): Simplify<UnionToIntersection<ParamKeyToRecord<ParamKeys<P2>>>>;
-  /**
-   * `.query()` can get querystring parameters.
-   *
-   * @see {@link https://hono.dev/docs/api/request#query}
-   *
-   * @example
-   * ```ts
-   * // Query params
-   * app.get('/search', (c) => {
-   *   const query = c.req.query('q')
-   * })
-   *
-   * // Get all params at once
-   * app.get('/search', (c) => {
-   *   const { q, limit, offset } = c.req.query()
-   * })
-   * ```
-   */
-  query(key: string): string | undefined;
-  query(): Record<string, string>;
-  /**
-   * `.queries()` can get multiple querystring parameter values, e.g. /search?tags=A&tags=B
-   *
-   * @see {@link https://hono.dev/docs/api/request#queries}
-   *
-   * @example
-   * ```ts
-   * app.get('/search', (c) => {
-   *   // tags will be string[]
-   *   const tags = c.req.queries('tags')
-   * })
-   * ```
-   */
-  queries(key: string): string[] | undefined;
-  queries(): Record<string, string[]>;
-  /**
-   * `.header()` can get the request header value.
-   *
-   * @see {@link https://hono.dev/docs/api/request#header}
-   *
-   * @example
-   * ```ts
-   * app.get('/', (c) => {
-   *   const userAgent = c.req.header('User-Agent')
-   * })
-   * ```
-   */
-  header(name: RequestHeader): string | undefined;
-  header(name: string): string | undefined;
-  header(): Record<RequestHeader | (string & CustomHeader), string>;
-  /**
-   * `.parseBody()` can parse Request body of type `multipart/form-data` or `application/x-www-form-urlencoded`
-   *
-   * @see {@link https://hono.dev/docs/api/request#parsebody}
-   *
-   * @example
-   * ```ts
-   * app.post('/entry', async (c) => {
-   *   const body = await c.req.parseBody()
-   * })
-   * ```
-   */
-  parseBody<Options extends Partial<ParseBodyOptions>, T extends BodyData<Options>>(options?: Options): Promise<T>;
-  parseBody<T extends BodyData>(options?: Partial<ParseBodyOptions>): Promise<T>;
-  /**
-   * `.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<T = any>(): Promise<T>;
-  /**
-   * `.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(): Promise<string>;
-  /**
-   * `.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(): Promise<ArrayBuffer>;
-  /**
-   * `.bytes()` parses the request body as a `Uint8Array`.
-   *
-   * @see {@link https://hono.dev/docs/api/request#bytes}
-   *
-   * @example
-   * ```ts
-   * app.post('/entry', async (c) => {
-   *   const body = await c.req.bytes()
-   * })
-   * ```
-   */
-  bytes(): Promise<Uint8Array>;
-  /**
-   * 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(): Promise<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(): Promise<FormData>;
-  /**
-   * Adds validated data to the request.
-   *
-   * @param target - The target of the validation.
-   * @param data - The validated data to add.
-   */
-  addValidatedData(target: keyof ValidationTargets, data: {}): void;
-  /**
-   * Gets validated data from the request.
-   *
-   * @param target - The target of the validation.
-   * @returns The validated data.
-   *
-   * @see https://hono.dev/docs/api/request#valid
-   */
-  valid<T extends keyof I & keyof ValidationTargets>(target: T): InputToDataByTarget<I, T>;
-  /**
-   * `.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(): string;
-  /**
-   * `.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(): string;
-  get [GET_MATCH_RESULT](): Result<[unknown, RouterRoute]>;
-  /**
-   * `.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(): RouterRoute[];
-  /**
-   * `.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(): string;
-}
-/**
- * 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 declare const cloneRawRequest: (req: HonoRequest) => Promise<Request>;
-//#endregion
-export {};

package/node_modules/hono/dist/types/router/linear-router/index.d.ts

@@ -1,2 +0,0 @@
-import { LinearRouter } from "./router.js";
-export { LinearRouter };

package/node_modules/hono/dist/types/router/linear-router/router.d.ts

@@ -1,9 +0,0 @@
-import { Result, Router } from "../../router.js";
-//#region src/router/linear-router/router.d.ts
-export declare class LinearRouter<T> implements Router<T> {
-  
-  name: string;
-  add(method: string, path: string, handler: T): void;
-  match(method: string, path: string): Result<T>;
-}
-//#endregion

package/node_modules/hono/dist/types/router/pattern-router/index.d.ts

@@ -1,2 +0,0 @@
-import { PatternRouter } from "./router.js";
-export { PatternRouter };

package/node_modules/hono/dist/types/router/pattern-router/router.d.ts

@@ -1,9 +0,0 @@
-import { Result, Router } from "../../router.js";
-//#region src/router/pattern-router/router.d.ts
-export declare class PatternRouter<T> implements Router<T> {
-  
-  name: string;
-  add(method: string, path: string, handler: T): void;
-  match(method: string, path: string): Result<T>;
-}
-//#endregion

package/node_modules/hono/dist/types/router/reg-exp-router/index.d.ts

@@ -1,3 +0,0 @@
-import { RegExpRouter } from "./router.js";
-import { PreparedRegExpRouter, buildInitParams, serializeInitParams } from "./prepared-router.js";
-export { PreparedRegExpRouter, RegExpRouter, buildInitParams, serializeInitParams };

package/node_modules/hono/dist/types/router/reg-exp-router/matcher.d.ts

@@ -1,9 +0,0 @@
-import { ParamIndexMap, Result, Router } from "../../router.js";
-//#region src/router/reg-exp-router/matcher.d.ts
-export type HandlerData<T> = [T, ParamIndexMap][];
-export type StaticMap<T> = Record<string, Result<T>>;
-export type Matcher<T> = [RegExp, HandlerData<T>[], StaticMap<T>];
-export type MatcherMap<T> = Record<string, Matcher<T> | null>;
-export declare const emptyParam: string[];
-export declare function match<R extends Router<T>, T>(this: R, method: string, path: string): Result<T>;
-//#endregion

package/node_modules/hono/dist/types/router/reg-exp-router/node.d.ts

@@ -1,15 +0,0 @@
-//#region src/router/reg-exp-router/node.d.ts
-export declare const LABEL_REG_EXP_STR = "[^/]+";
-export declare const ONLY_WILDCARD_REG_EXP_STR = "[^]*";
-export declare const TAIL_WILDCARD_REG_EXP_STR = "(?:|/[^]*)";
-export declare const PATH_ERROR: unique symbol;
-export type ParamAssocArray = [string, number][];
-export interface Context {
-  varIndex: number;
-}
-export declare class Node {
-  
-  insert(tokens: readonly string[], index: number, paramMap: ParamAssocArray, context: Context, keys: string[]): void;
-  buildRegExpStr(): string;
-}
-//#endregion

package/node_modules/hono/dist/types/router/reg-exp-router/prepared-router.d.ts

@@ -1,18 +0,0 @@
-import { ParamIndexMap, Router } from "../../router.js";
-import { MatcherMap, match } from "./matcher.js";
-//#region src/router/reg-exp-router/prepared-router.d.ts
-type RelocateMap = Record<string, ([(number | string)[], ParamIndexMap] | [(number | string)[]])[]>;
-export declare class PreparedRegExpRouter<T> implements Router<T> {
-  
-  name: string;
-  constructor(matchers: MatcherMap<T>, relocateMap: RelocateMap);
-  add(method: string, path: string, handler: T): void;
-  protected buildAllMatchers(): MatcherMap<T>;
-  match: typeof match<Router<T>, T>;
-}
-export declare const buildInitParams: (params: {
-  paths: string[];
-}) => ConstructorParameters<typeof PreparedRegExpRouter>;
-export declare const serializeInitParams: (params: ConstructorParameters<typeof PreparedRegExpRouter>) => string;
-//#endregion
-export {};

package/node_modules/hono/dist/types/router/reg-exp-router/router.d.ts

@@ -1,12 +0,0 @@
-import { Router } from "../../router.js";
-import { MatcherMap, match } from "./matcher.js";
-//#region src/router/reg-exp-router/router.d.ts
-export declare class RegExpRouter<T> implements Router<T> {
-  
-  name: string;
-  constructor();
-  add(method: string, path: string, handler: T): void;
-  match: typeof match<Router<T>, T>;
-  protected buildAllMatchers(): MatcherMap<T>;
-}
-//#endregion

package/node_modules/hono/dist/types/router/reg-exp-router/trie.d.ts

@@ -1,10 +0,0 @@
-import { ParamAssocArray } from "./node.js";
-//#region src/router/reg-exp-router/trie.d.ts
-export type ReplacementMap = number[];
-export declare class Trie {
-  
-  paths: Record<string, [number, ParamAssocArray, string[]]>;
-  insert(path: string, isStatic: boolean): void;
-  buildRegExp(): [RegExp, ReplacementMap, ReplacementMap];
-}
-//#endregion

package/node_modules/hono/dist/types/router/smart-router/index.d.ts

@@ -1,2 +0,0 @@
-import { SmartRouter } from "./router.js";
-export { SmartRouter };

package/node_modules/hono/dist/types/router/smart-router/router.d.ts

@@ -1,13 +0,0 @@
-import { Result, Router } from "../../router.js";
-//#region src/router/smart-router/router.d.ts
-export declare class SmartRouter<T> implements Router<T> {
-  
-  name: string;
-  constructor(init: {
-    routers: Router<T>[];
-  });
-  add(method: string, path: string, handler: T): void;
-  match(method: string, path: string): Result<T>;
-  get activeRouter(): Router<T>;
-}
-//#endregion

package/node_modules/hono/dist/types/router/trie-router/index.d.ts

@@ -1,2 +0,0 @@
-import { TrieRouter } from "./router.js";
-export { TrieRouter };

package/node_modules/hono/dist/types/router/trie-router/node.d.ts

@@ -1,8 +0,0 @@
-import { Params } from "../../router.js";
-//#region src/router/trie-router/node.d.ts
-export declare class Node<T> {
-  
-  insert(method: string, path: string, handler: T): void;
-  search(method: string, path: string): [[T, Params][]];
-}
-//#endregion

package/node_modules/hono/dist/types/router/trie-router/router.d.ts

@@ -1,9 +0,0 @@
-import { Result, Router } from "../../router.js";
-//#region src/router/trie-router/router.d.ts
-export declare class TrieRouter<T> implements Router<T> {
-  
-  name: string;
-  add(method: string, path: string, handler: T): void;
-  match(method: string, path: string): Result<T>;
-}
-//#endregion

package/node_modules/hono/dist/types/router/utils.d.ts

@@ -1,3 +0,0 @@
-//#region src/router/utils.d.ts
-export declare const createNullObject: () => any;
-//#endregion

package/node_modules/hono/dist/types/router.d.ts

@@ -1,98 +0,0 @@
-//#region src/router.d.ts
-/**
- * @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", "query"];
-/**
- * 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 {}
-//#endregion