@zuplo/cli 7.8.18 → 7.8.20

package/node_modules/hono/dist/types/hono-base.d.ts

@@ -1,221 +1,218 @@
-/**
- * @module
- * This module is the base module for the Hono object.
- */
-import { Context } from './context';
-import type { ExecutionContext } from './context';
-import type { Router } from './router';
-import type { Env, ErrorHandler, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, RouterRoute, Schema } from './types';
+import { Router } from "./router.js";
+import { Env, ErrorHandler, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, RouterRoute, Schema } from "./types.js";
+import { Context, ExecutionContext } from "./context.js";
+//#region src/hono-base.d.ts
 type GetPath<E extends Env> = (request: Request, options?: {
-    env?: E['Bindings'];
+  env?: E['Bindings'];
 }) => string;
 export type HonoOptions<E extends Env> = {
-    /**
-     * `strict` option specifies whether to distinguish whether the last path is a directory or not.
-     *
-     * @see {@link https://hono.dev/docs/api/hono#strict-mode}
-     *
-     * @default true
-     */
-    strict?: boolean;
-    /**
-     * `router` option specifies which router to use.
-     *
-     * @see {@link https://hono.dev/docs/api/hono#router-option}
-     *
-     * @example
-     * ```ts
-     * const app = new Hono({ router: new RegExpRouter() })
-     * ```
-     */
-    router?: Router<[H, RouterRoute]>;
-    /**
-     * `getPath` can handle the host header value.
-     *
-     * @see {@link https://hono.dev/docs/api/routing#routing-with-host-header-value}
-     *
-     * @example
-     * ```ts
-     * const app = new Hono({
-     *  getPath: (req) =>
-     *   '/' + req.headers.get('host') + req.url.replace(/^https?:\/\/[^/]+(\/[^?]*)/, '$1'),
-     * })
-     *
-     * app.get('/www1.example.com/hello', () => c.text('hello www1'))
-     *
-     * // A following request will match the route:
-     * // new Request('http://www1.example.com/hello', {
-     * //  headers: { host: 'www1.example.com' },
-     * // })
-     * ```
-     */
-    getPath?: GetPath<E>;
+  /**
+   * `strict` option specifies whether to distinguish whether the last path is a directory or not.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#strict-mode}
+   *
+   * @default true
+   */
+  strict?: boolean;
+  /**
+   * `router` option specifies which router to use.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#router-option}
+   *
+   * @example
+   * ```ts
+   * const app = new Hono({ router: new RegExpRouter() })
+   * ```
+   */
+  router?: Router<[H, RouterRoute]>;
+  /**
+   * `getPath` can handle the host header value.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#routing-with-host-header-value}
+   *
+   * @example
+   * ```ts
+   * const app = new Hono({
+   *  getPath: (req) =>
+   *   '/' + req.headers.get('host') + req.url.replace(/^https?:\/\/[^/]+(\/[^?]*)/, '$1'),
+   * })
+   *
+   * app.get('/www1.example.com/hello', () => c.text('hello www1'))
+   *
+   * // A following request will match the route:
+   * // new Request('http://www1.example.com/hello', {
+   * //  headers: { host: 'www1.example.com' },
+   * // })
+   * ```
+   */
+  getPath?: GetPath<E>;
 };
 type MountOptionHandler = (c: Context) => unknown;
 type MountReplaceRequest = (originalRequest: Request) => Request;
 type MountOptions = MountOptionHandler | {
-    optionHandler?: MountOptionHandler;
-    replaceRequest?: MountReplaceRequest | false;
+  optionHandler?: MountOptionHandler;
+  replaceRequest?: MountReplaceRequest | false;
 };
 declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/', CurrentPath extends string = BasePath> {
-             
-    get: HandlerInterface<E, 'get', S, BasePath, CurrentPath>;
-    post: HandlerInterface<E, 'post', S, BasePath, CurrentPath>;
-    put: HandlerInterface<E, 'put', S, BasePath, CurrentPath>;
-    delete: HandlerInterface<E, 'delete', S, BasePath, CurrentPath>;
-    options: HandlerInterface<E, 'options', S, BasePath, CurrentPath>;
-    patch: HandlerInterface<E, 'patch', S, BasePath, CurrentPath>;
-    query: HandlerInterface<E, 'query', S, BasePath, CurrentPath>;
-    all: HandlerInterface<E, 'all', S, BasePath, CurrentPath>;
-    on: OnHandlerInterface<E, S, BasePath>;
-    use: MiddlewareHandlerInterface<E, S, BasePath>;
-    router: Router<[H, RouterRoute]>;
-    readonly getPath: GetPath<E>;
-    private _basePath;
-    routes: RouterRoute[];
-    constructor(options?: HonoOptions<E>);
-    private errorHandler;
-    /**
-     * `.route()` allows grouping other Hono instance in routes.
-     *
-     * @see {@link https://hono.dev/docs/api/routing#grouping}
-     *
-     * @param {string} path - base Path
-     * @param {Hono} app - other Hono instance
-     * @returns {Hono} routed Hono instance
-     *
-     * @example
-     * ```ts
-     * const app = new Hono()
-     * const app2 = new Hono()
-     *
-     * app2.get("/user", (c) => c.text("user"))
-     * app.route("/api", app2) // GET /api/user
-     * ```
-     */
-    route<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string, SubCurrentPath extends string>(path: SubPath, app: Hono<SubEnv, SubSchema, SubBasePath, SubCurrentPath>): Hono<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> | S, BasePath, CurrentPath>;
-    /**
-     * `.basePath()` allows base paths to be specified.
-     *
-     * @see {@link https://hono.dev/docs/api/routing#base-path}
-     *
-     * @param {string} path - base Path
-     * @returns {Hono} changed Hono instance
-     *
-     * @example
-     * ```ts
-     * const api = new Hono().basePath('/api')
-     * ```
-     */
-    basePath<SubPath extends string>(path: SubPath): Hono<E, S, MergePath<BasePath, SubPath>, MergePath<BasePath, SubPath>>;
-    /**
-     * `.onError()` handles an error and returns a customized Response.
-     *
-     * @see {@link https://hono.dev/docs/api/hono#error-handling}
-     *
-     * @param {ErrorHandler} handler - request Handler for error
-     * @returns {Hono} changed Hono instance
-     *
-     * @example
-     * ```ts
-     * app.onError((err, c) => {
-     *   console.error(`${err}`)
-     *   return c.text('Custom Error Message', 500)
-     * })
-     * ```
-     */
-    onError: (handler: ErrorHandler<E>) => Hono<E, S, BasePath, CurrentPath>;
-    /**
-     * `.notFound()` allows you to customize a Not Found Response.
-     *
-     * @see {@link https://hono.dev/docs/api/hono#not-found}
-     *
-     * @param {NotFoundHandler} handler - request handler for not-found
-     * @returns {Hono} changed Hono instance
-     *
-     * @example
-     * ```ts
-     * app.notFound((c) => {
-     *   return c.text('Custom 404 Message', 404)
-     * })
-     * ```
-     */
-    notFound: (handler: NotFoundHandler<E>) => Hono<E, S, BasePath, CurrentPath>;
-    /**
-     * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
-     *
-     * @see {@link https://hono.dev/docs/api/hono#mount}
-     *
-     * @param {string} path - base Path
-     * @param {Function} applicationHandler - other Request Handler
-     * @param {MountOptions} [options] - options of `.mount()`
-     * @returns {Hono} mounted Hono instance
-     *
-     * @example
-     * ```ts
-     * import { Router as IttyRouter } from 'itty-router'
-     * import { Hono } from 'hono'
-     * // Create itty-router application
-     * const ittyRouter = IttyRouter()
-     * // GET /itty-router/hello
-     * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
-     *
-     * const app = new Hono()
-     * app.mount('/itty-router', ittyRouter.handle)
-     * ```
-     *
-     * @example
-     * ```ts
-     * const app = new Hono()
-     * // Send the request to another application without modification.
-     * app.mount('/app', anotherApp, {
-     *   replaceRequest: (req) => req,
-     * })
-     * ```
-     */
-    mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Hono<E, S, BasePath, CurrentPath>;
-    /**
-     * `.fetch()` will be entry point of your app.
-     *
-     * @see {@link https://hono.dev/docs/api/hono#fetch}
-     *
-     * @param {Request} request - request Object of request
-     * @param {Env} env - env Object
-     * @param {ExecutionContext} executionCtx - context of execution
-     * @returns {Response | Promise<Response>} response of request
-     *
-     */
-    fetch: (request: Request, env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
-    /**
-     * `.request()` is a useful method for testing.
-     * You can pass a URL or pathname to send a GET request.
-     * app will return a Response object.
-     * ```ts
-     * test('GET /hello is ok', async () => {
-     *   const res = await app.request('/hello')
-     *   expect(res.status).toBe(200)
-     * })
-     * ```
-     * @see https://hono.dev/docs/api/hono#request
-     */
-    request: (input: Request | string | URL, requestInit?: RequestInit, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
-    /**
-     * `.fire()` automatically adds a global fetch event listener.
-     * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
-     * @deprecated
-     * Use `fire` from `hono/service-worker` instead.
-     * ```ts
-     * import { Hono } from 'hono'
-     * import { fire } from 'hono/service-worker'
-     *
-     * const app = new Hono()
-     * // ...
-     * fire(app)
-     * ```
-     * @see https://hono.dev/docs/api/hono#fire
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
-     * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
-     */
-    fire: () => void;
+  
+  get: HandlerInterface<E, 'get', S, BasePath, CurrentPath>;
+  post: HandlerInterface<E, 'post', S, BasePath, CurrentPath>;
+  put: HandlerInterface<E, 'put', S, BasePath, CurrentPath>;
+  delete: HandlerInterface<E, 'delete', S, BasePath, CurrentPath>;
+  options: HandlerInterface<E, 'options', S, BasePath, CurrentPath>;
+  patch: HandlerInterface<E, 'patch', S, BasePath, CurrentPath>;
+  query: HandlerInterface<E, 'query', S, BasePath, CurrentPath>;
+  all: HandlerInterface<E, 'all', S, BasePath, CurrentPath>;
+  on: OnHandlerInterface<E, S, BasePath>;
+  use: MiddlewareHandlerInterface<E, S, BasePath>;
+  router: Router<[H, RouterRoute]>;
+  readonly getPath: GetPath<E>;
+  private _basePath;
+  routes: RouterRoute[];
+  constructor(options?: HonoOptions<E>);
+  private errorHandler;
+  /**
+   * `.route()` allows grouping other Hono instance in routes.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#grouping}
+   *
+   * @param {string} path - base Path
+   * @param {Hono} app - other Hono instance
+   * @returns {Hono} routed Hono instance
+   *
+   * @example
+   * ```ts
+   * const app = new Hono()
+   * const app2 = new Hono()
+   *
+   * app2.get("/user", (c) => c.text("user"))
+   * app.route("/api", app2) // GET /api/user
+   * ```
+   */
+  route<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string, SubCurrentPath extends string>(path: SubPath, app: Hono<SubEnv, SubSchema, SubBasePath, SubCurrentPath>): Hono<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> | S, BasePath, CurrentPath>;
+  /**
+   * `.basePath()` allows base paths to be specified.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#base-path}
+   *
+   * @param {string} path - base Path
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * const api = new Hono().basePath('/api')
+   * ```
+   */
+  basePath<SubPath extends string>(path: SubPath): Hono<E, S, MergePath<BasePath, SubPath>, MergePath<BasePath, SubPath>>;
+  /**
+   * `.onError()` handles an error and returns a customized Response.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#error-handling}
+   *
+   * @param {ErrorHandler} handler - request Handler for error
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * app.onError((err, c) => {
+   *   console.error(`${err}`)
+   *   return c.text('Custom Error Message', 500)
+   * })
+   * ```
+   */
+  onError: (handler: ErrorHandler<E>) => Hono<E, S, BasePath, CurrentPath>;
+  /**
+   * `.notFound()` allows you to customize a Not Found Response.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#not-found}
+   *
+   * @param {NotFoundHandler} handler - request handler for not-found
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * app.notFound((c) => {
+   *   return c.text('Custom 404 Message', 404)
+   * })
+   * ```
+   */
+  notFound: (handler: NotFoundHandler<E>) => Hono<E, S, BasePath, CurrentPath>;
+  /**
+   * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#mount}
+   *
+   * @param {string} path - base Path
+   * @param {Function} applicationHandler - other Request Handler
+   * @param {MountOptions} [options] - options of `.mount()`
+   * @returns {Hono} mounted Hono instance
+   *
+   * @example
+   * ```ts
+   * import { Router as IttyRouter } from 'itty-router'
+   * import { Hono } from 'hono'
+   * // Create itty-router application
+   * const ittyRouter = IttyRouter()
+   * // GET /itty-router/hello
+   * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+   *
+   * const app = new Hono()
+   * app.mount('/itty-router', ittyRouter.handle)
+   * ```
+   *
+   * @example
+   * ```ts
+   * const app = new Hono()
+   * // Send the request to another application without modification.
+   * app.mount('/app', anotherApp, {
+   *   replaceRequest: (req) => req,
+   * })
+   * ```
+   */
+  mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Hono<E, S, BasePath, CurrentPath>;
+  /**
+   * `.fetch()` will be entry point of your app.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#fetch}
+   *
+   * @param {Request} request - request Object of request
+   * @param {Env} env - env Object
+   * @param {ExecutionContext} executionCtx - context of execution
+   * @returns {Response | Promise<Response>} response of request
+   *
+   */
+  fetch: (request: Request, env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
+  /**
+   * `.request()` is a useful method for testing.
+   * You can pass a URL or pathname to send a GET request.
+   * app will return a Response object.
+   * ```ts
+   * test('GET /hello is ok', async () => {
+   *   const res = await app.request('/hello')
+   *   expect(res.status).toBe(200)
+   * })
+   * ```
+   * @see https://hono.dev/docs/api/hono#request
+   */
+  request: (input: Request | string | URL, requestInit?: RequestInit, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
+  /**
+   * `.fire()` automatically adds a global fetch event listener.
+   * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
+   * @deprecated
+   * Use `fire` from `hono/service-worker` instead.
+   * ```ts
+   * import { Hono } from 'hono'
+   * import { fire } from 'hono/service-worker'
+   *
+   * const app = new Hono()
+   * // ...
+   * fire(app)
+   * ```
+   * @see https://hono.dev/docs/api/hono#fire
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+   * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
+   */
+  fire: () => void;
 }
-export { Hono as HonoBase };
+//#endregion
+export { Hono as HonoBase };

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

@@ -1,6 +1,6 @@
-import { HonoBase } from './hono-base';
-import type { HonoOptions } from './hono-base';
-import type { BlankEnv, BlankSchema, Env, Schema } from './types';
+import { HonoBase as Hono$1, HonoOptions } from "./hono-base.js";
+import { BlankEnv, BlankSchema, Env, Schema } from "./types.js";
+//#region src/hono.d.ts
 /**
  * The Hono class extends the functionality of the HonoBase class.
  * It sets up routing and allows for custom options to be passed.
@@ -9,11 +9,12 @@ import type { BlankEnv, BlankSchema, Env, Schema } from './types';
  * @template S - The schema type.
  * @template BasePath - The base path type.
  */
-export declare class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
-    /**
-     * Creates an instance of the Hono class.
-     *
-     * @param options - Optional configuration options for the Hono instance.
-     */
-    constructor(options?: HonoOptions<E>);
+export declare class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends Hono$1<E, S, BasePath> {
+  /**
+   * Creates an instance of the Hono class.
+   *
+   * @param options - Optional configuration options for the Hono instance.
+   */
+  constructor(options?: HonoOptions<E>);
 }
+//#endregion

package/node_modules/hono/dist/types/http-exception.d.ts

@@ -1,8 +1,5 @@
-/**
- * @module
- * This module provides the `HTTPException` class.
- */
-import type { ContentfulStatusCode } from './utils/http-status';
+import { ContentfulStatusCode } from "./utils/http-status.js";
+//#region src/http-exception.d.ts
 /**
  * Options for creating an `HTTPException`.
  * @property res - Optional response object to use.
@@ -10,9 +7,9 @@ import type { ContentfulStatusCode } from './utils/http-status';
  * @property cause - Optional cause of the error.
  */
 type HTTPExceptionOptions = {
-    res?: Response;
-    message?: string;
-    cause?: unknown;
+  res?: Response;
+  message?: string;
+  cause?: unknown;
 };
 /**
  * `HTTPException` must be used when a fatal error such as authentication failure occurs.
@@ -41,19 +38,19 @@ type HTTPExceptionOptions = {
  * ```
  */
 export declare class HTTPException extends Error {
-    readonly res?: Response;
-    readonly status: ContentfulStatusCode;
-    /**
-     * Creates an instance of `HTTPException`.
-     * @param status - HTTP status code for the exception. Defaults to 500.
-     * @param options - Additional options for the exception.
-     */
-    constructor(status?: ContentfulStatusCode, options?: HTTPExceptionOptions);
-    /**
-     * Returns the response object associated with the exception.
-     * If a response object is not provided, a new response is created with the error message and status code.
-     * @returns The response object.
-     */
-    getResponse(): Response;
+  readonly res?: Response;
+  readonly status: ContentfulStatusCode;
+  /**
+   * Creates an instance of `HTTPException`.
+   * @param status - HTTP status code for the exception. Defaults to 500.
+   * @param options - Additional options for the exception.
+   */
+  constructor(status?: ContentfulStatusCode, options?: HTTPExceptionOptions);
+  /**
+   * Returns the response object associated with the exception.
+   * If a response object is not provided, a new response is created with the error message and status code.
+   * @returns The response object.
+   */
+  getResponse(): Response;
 }
-export {};
+//#endregion

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

@@ -1,37 +1,6 @@
-/**
- * @module
- *
- * Hono - Web Framework built on Web Standards
- *
- * @example
- * ```ts
- * import { Hono } from 'hono'
- * const app = new Hono()
- *
- * app.get('/', (c) => c.text('Hono!'))
- *
- * export default app
- * ```
- */
-import { Hono } from './hono';
-/**
- * Types for environment variables, error handlers, handlers, middleware handlers, and more.
- */
-export type { Env, ErrorHandler, Handler, MiddlewareHandler, Next, NotFoundResponse, NotFoundHandler, ValidationTargets, Input, Schema, ToSchema, TypedResponse, } from './types';
-/**
- * Types for context, context variable map, context renderer, and execution context.
- */
-export { Context } from './context';
-export type { ContextVariableMap, ContextRenderer, ExecutionContext } from './context';
-/**
- * Type for HonoRequest.
- */
-export type { HonoRequest } from './request';
-/**
- * Types for inferring request and response types and client request options.
- */
-export type { InferRequestType, InferResponseType, ClientRequestOptions } from './client';
-/**
- * Hono framework for building web applications.
- */
-export { Hono };
+import { Env, ErrorHandler, Handler, Input, MiddlewareHandler, Next, NotFoundHandler, NotFoundResponse, Schema, ToSchema, TypedResponse, ValidationTargets } from "./types.js";
+import { HonoRequest } from "./request.js";
+import { Context, ContextRenderer, ContextVariableMap, ExecutionContext } from "./context.js";
+import { Hono } from "./hono.js";
+import { ClientRequestOptions, InferRequestType, InferResponseType } from "./client/types.js";
+export { type ClientRequestOptions, Context, type ContextRenderer, type ContextVariableMap, type Env, type ErrorHandler, type ExecutionContext, type Handler, Hono, type HonoRequest, type InferRequestType, type InferResponseType, type Input, type MiddlewareHandler, type Next, type NotFoundHandler, type NotFoundResponse, type Schema, type ToSchema, type TypedResponse, type ValidationTargets };