hono 4.13.13 → 5.0.0-rc.1

package/dist/helper/factory/define-handler.d.ts

@@ -0,0 +1,150 @@
+import { ContentfulStatusCode } from "../../utils/http-status.js";
+import { JSONParsed } from "../../utils/types.js";
+import { Env, FormValue, Handler, IntersectNonAnyTypes, MiddlewareHandler, TypedResponse, ValidationTargets } from "../../types.js";
+import { Context } from "../../context.js";
+import { HtmlEscaped } from "../../utils/html.js";
+import { InferInput } from "../../validator/utils.js";
+//#region src/helper/factory/define-handler.d.ts
+type StandardSchemaIssue = {
+  readonly message: string;
+  readonly path?: ReadonlyArray<PropertyKey | {
+    readonly key: PropertyKey;
+  }> | undefined;
+};
+type StandardSchemaResult<Output> = {
+  readonly value: Output;
+  readonly issues?: undefined;
+} | {
+  readonly issues: ReadonlyArray<StandardSchemaIssue>;
+};
+/**
+ * The part of the Standard Schema interface used by `defineHandler()`.
+ * @see {@link https://standardschema.dev/}
+ */
+export type StandardSchema<Input = unknown, Output = Input> = {
+  readonly '~standard': {
+    readonly validate: (value: unknown) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+    readonly types?: {
+      readonly input: Input;
+      readonly output: Output;
+    } | undefined;
+  };
+};
+type AnyStandardSchema = StandardSchema<any, any>;
+type AnyResponse = Response | TypedResponse<any, any, any>;
+/**
+ * A Standard Schema or a validation function for `Value`.
+ * `T` is the schema itself, or the output of the function. It is `never` when not specified.
+ */
+type Validation<Value, T> = (T & AnyStandardSchema) | ((value: Value, c: Context<any, any, any>) => T | Promise<T>);
+type ResponseValidation<In, Out> = (Out & StandardSchema<In, any>) | ((value: In, c: Context<any, any, any>) => Out | Promise<Out>);
+/**
+ * A Response the handler can return. A JSON Response by `c.json()` is not accepted,
+ * because it bypasses the response validation. Return the value instead.
+ */
+type NonJSONResponse = Response & {
+  readonly _format?: 'text' | 'redirect' | 'body';
+};
+type InputOf<T> = T extends StandardSchema<infer I, any> ? I : Exclude<T, AnyResponse>;
+type OutputOf<T> = T extends StandardSchema<any, infer O> ? O : Exclude<T, AnyResponse>;
+type RequestTarget = keyof ValidationTargets;
+type Targets = { [K in RequestTarget]: unknown; };
+type ValidatedTarget<T extends Targets> = { [K in RequestTarget]: [T[K]] extends [never] ? never : K; }[RequestTarget];
+type ValidatedInput<T extends Targets> = {
+  in: { [K in ValidatedTarget<T>]: K extends 'json' ? InputOf<T[K]> : InferInput<InputOf<T[K]>, K, FormValue>; };
+  out: { [K in ValidatedTarget<T>]: OutputOf<T[K]>; };
+};
+/** The validated values, passed to the handler as the second argument */
+type HandlerInput<T extends Targets> = { [K in ValidatedTarget<T>]: OutputOf<T[K]>; };
+type JSONResponseOf<T> = Response & TypedResponse<JSONParsed<T>, ContentfulStatusCode, 'json'>;
+/** The Response that `toResponse()` converts a returned value to */
+type ConvertedResponse<R> = [unknown] extends [R] ? Response : R extends AnyResponse ? R : R extends null | undefined | void ? Response & TypedResponse<null, 204, 'body'> : R extends string | HtmlEscaped ? Response : JSONResponseOf<R>;
+type AnyMiddleware = MiddlewareHandler<any, any, any>;
+type MiddlewareEnvs<M extends AnyMiddleware[]> = { [K in keyof M]: M[K] extends MiddlewareHandler<infer ME, any, any> ? ME : never; };
+/**
+ * An issue in the failure response. `path` is dot-joined, e.g. `user.email`.
+ * The input value is not included.
+ */
+export type ValidationIssue = {
+  message: string;
+  path?: string;
+};
+/** The issues of one validation target in the failure response */
+export type ValidationFailure = {
+  slot: RequestTarget | 'response';
+  issues: ValidationIssue[];
+};
+type ValidatedHandlerOptions<Param, Query, Header, Cookie, Form, Json, ResponseIn, ResponseOut> = {
+  param?: Validation<ValidationTargets['param'], Param>;
+  query?: Validation<ValidationTargets['query'], Query>;
+  header?: Validation<ValidationTargets['header'], Header>;
+  cookie?: Validation<ValidationTargets['cookie'], Cookie>;
+  form?: Validation<ValidationTargets['form'], Form>;
+  json?: Validation<ValidationTargets['json'], Json>;
+  response?: ResponseValidation<ResponseIn, ResponseOut>;
+};
+type ValidatedHandler<E extends Env, P extends string, T extends Targets, ResponseOut, R> = Handler<E, P, ValidatedInput<T>, Promise<[ResponseOut] extends [never] ? ConvertedResponse<Awaited<R>> : JSONResponseOf<OutputOf<ResponseOut>>>>;
+export interface DefineHandler<E extends Env, P extends string> {
+  /**
+   * Defines a handler, with middleware before it. The returned value is converted to a Response.
+   */
+  <E2 extends Env = E, P2 extends string = P, M extends AnyMiddleware[] = [], R = unknown>(...args: [...middleware: M, handler: (c: Context<IntersectNonAnyTypes<[E2, ...MiddlewareEnvs<M>]>, P2>) => R]): Handler<E2, P2, {}, Promise<ConvertedResponse<Awaited<R>>>>;
+  /**
+   * Defines a handler with request and response validation, with middleware before it.
+   */
+  <Param = never, Query = never, Header = never, Cookie = never, Form = never, Json = never, ResponseIn = unknown, ResponseOut = never, T extends Targets = {
+    param: Param;
+    query: Query;
+    header: Header;
+    cookie: Cookie;
+    form: Form;
+    json: Json;
+  }>(options: ValidatedHandlerOptions<Param, Query, Header, Cookie, Form, Json, ResponseIn, ResponseOut>): <E2 extends Env = E, P2 extends string = P, M extends AnyMiddleware[] = [], R extends ResponseIn | NonJSONResponse | Promise<ResponseIn | NonJSONResponse> = ResponseIn>(...args: [...middleware: M, handler: (c: Context<IntersectNonAnyTypes<[E2, ...MiddlewareEnvs<M>]>, P2, ValidatedInput<T>>, input: HandlerInput<T>) => R]) => ValidatedHandler<E2, P2, T, ResponseOut, R>;
+}
+/**
+ * `defineHandler()` defines a handler. A value returned from the handler is converted to a
+ * Response: an object is returned as JSON, a string or JSX as HTML, and `null` or `undefined`
+ * as `204 No Content`. A `Response` is returned as is. The status is set with `c.status()`, and
+ * it is not in the types. Return `c.json()` to have the status in the types.
+ *
+ * With options, each request target (`param`, `query`, `json`, `form`, `header`, `cookie`)
+ * is validated before the handler runs. The validated values are passed to the handler as
+ * the second argument, and are also available through `c.req.valid()`.
+ * A value returned from the handler is validated with `response` and returned as JSON.
+ *
+ * Each validation accepts a Standard Schema or a validation function.
+ * When a Standard Schema fails, an `HTTPException` is thrown with status 400 for the request
+ * and 500 for the response, so `onError` can handle it. Its `res` is a JSON response of
+ * `{ error, issues }`, and its `cause` is `{ issues }` with the raw Standard Schema issues.
+ *
+ * Middleware passed before the handler runs first, around the validation. Its Env flows into
+ * the handler, so `c.get()` is typed. Otherwise, use `createFactory<Env>().defineHandler`, or
+ * pass the Env and the path as type arguments.
+ *
+ * @see {@link https://hono.dev/docs/helpers/factory#definehandler}
+ *
+ * @experimental
+ * `defineHandler()` is an experimental feature.
+ * The API might be changed.
+ *
+ * @example
+ * ```ts
+ * app.get('/ping', defineHandler(() => ({ pong: true })))
+ * app.get('/me', defineHandler(auth, (c) => c.get('user')))
+ *
+ * app.post(
+ *   '/users/:id',
+ *   defineHandler({
+ *     param: ParamSchema,
+ *     json: BodySchema,
+ *     response: UserSchema,
+ *   })(async (c, { param, json }) => {
+ *     c.status(201)
+ *     return { id: param.id, ...json }
+ *   })
+ * )
+ * ```
+ */
+export declare const defineHandler: DefineHandler<any, any>;
+//#endregion
+export {};

package/dist/helper/factory/define-handler.js

@@ -0,0 +1,117 @@
+import { HTTPException } from "../../http-exception.js";
+import { getValidationTarget } from "../../validator/validator.js";
+//#region src/helper/factory/define-handler.ts
+const requestTargets = [
+	"param",
+	"query",
+	"header",
+	"cookie",
+	"form",
+	"json"
+];
+const isStandardSchema = (v) => (typeof v === "object" || typeof v === "function") && v !== null && "~standard" in v;
+const toValidationIssues = (issues) => issues.map(({ message, path }) => path ? {
+	message,
+	path: path.map((p) => String(typeof p === "object" ? p.key : p)).join(".")
+} : { message });
+const toValidator = (target, v) => isStandardSchema(v) ? {
+	target,
+	schema: v["~standard"].validate
+} : {
+	target,
+	fn: v
+};
+const toResponse = (c, result) => {
+	if (result instanceof Response) return result;
+	if (result === null || result === void 0) return c.body(null, 204);
+	return typeof result === "string" || result.isEscaped ? c.html(result) : c.json(result);
+};
+const defineHandler = ((...args) => {
+	if (typeof args[0] === "function") return compose(args, async (c) => toResponse(c, await args[args.length - 1](c)));
+	const options = args[0];
+	const validators = requestTargets.filter((target) => options[target]).map((target) => toValidator(target, options[target]));
+	const response = options.response && toValidator("json", options.response);
+	return (...args) => {
+		const handler = args[args.length - 1];
+		const run = async (c) => {
+			const input = {};
+			const failures = [];
+			const issues = [];
+			for (const { target, schema, fn } of validators) {
+				let value = getValidationTarget(c, target);
+				if (value instanceof Promise) value = await value;
+				if (schema) {
+					let result = schema(value);
+					if (result instanceof Promise) result = await result;
+					if (result.issues) {
+						failures.push({
+							slot: target,
+							issues: toValidationIssues(result.issues)
+						});
+						issues.push({
+							slot: target,
+							issues: result.issues
+						});
+						continue;
+					}
+					value = result.value;
+				} else {
+					value = fn(value, c);
+					if (value instanceof Promise) value = await value;
+					if (value instanceof Response) return value;
+				}
+				c.req.addValidatedData(target, value);
+				input[target] = value;
+			}
+			if (failures.length) throw new HTTPException(400, {
+				res: c.json({
+					error: "Validation failed",
+					issues: failures
+				}, 400),
+				cause: { issues }
+			});
+			let result = handler(c, input);
+			if (result instanceof Promise) result = await result;
+			if (result instanceof Response) return result;
+			if (response) {
+				if (response.schema) {
+					let validated = response.schema(result);
+					if (validated instanceof Promise) validated = await validated;
+					if (validated.issues) throw new HTTPException(500, {
+						res: c.json({ error: "Response validation failed" }, 500),
+						cause: { issues: [{
+							slot: "response",
+							issues: validated.issues
+						}] }
+					});
+					result = validated.value;
+				} else {
+					result = response.fn(result, c);
+					if (result instanceof Promise) result = await result;
+					if (result instanceof Response) return result;
+				}
+				return c.json(result);
+			}
+			return toResponse(c, result);
+		};
+		return Object.assign(compose(args, run), { validations: options });
+	};
+});
+const compose = (args, run) => {
+	const middleware = args.slice(0, -1);
+	if (!middleware.length) return run;
+	return async (c) => {
+		const dispatch = async (i) => {
+			if (i === middleware.length) {
+				c.res = await run(c);
+				return;
+			}
+			const res = await middleware[i](c, () => dispatch(i + 1));
+			if (res) c.res = res;
+		};
+		await dispatch(0);
+		return c.res;
+	};
+};
+//#endregion
+export { defineHandler };

package/dist/{types/helper → helper}/factory/index.d.ts

@@ -1,6 +1,7 @@
-import { HonoOptions } from "../../hono-base.js";
 import { Env, H, HandlerResponse, Input, IntersectNonAnyTypes, MiddlewareHandler } from "../../types.js";
+import { HonoOptions } from "../../hono-base.js";
 import { Hono } from "../../hono.js";
+import { DefineHandler, StandardSchema, ValidationFailure, ValidationIssue, defineHandler } from "./define-handler.js";
 //#region src/helper/factory/index.d.ts
 type InitApp<E extends Env = Env> = (app: Hono<E>) => void;
 export interface CreateHandlersInterface<E extends Env, P extends string> {
@@ -23,13 +24,41 @@ export declare class Factory<E extends Env = Env, P extends string = string> {
     defaultAppOptions?: HonoOptions<E>;
   });
   createApp: (options?: HonoOptions<E>) => Hono<E>;
+  defineMiddleware: <I extends Input = {}, R extends HandlerResponse<any> | void = void>(middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>) => MiddlewareHandler<E, P, I, R extends void ? Response : R>;
+  defineHandler: DefineHandler<E, P>;
+  /**
+   * @deprecated Use `defineMiddleware()` instead. It will be removed in the next major version.
+   */
   createMiddleware: <I extends Input = {}, R extends HandlerResponse<any> | void = void>(middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>) => MiddlewareHandler<E, P, I, R extends void ? Response : R>;
+  /**
+   * @deprecated Use `defineHandler()` instead. It will be removed in the next major version.
+   * Pass the middleware before the handler:
+   * `defineHandler(auth, (c) => ...)`.
+   */
   createHandlers: CreateHandlersInterface<E, P>;
 }
 export declare const createFactory: <E extends Env = Env, P extends string = string>(init?: {
   initApp?: InitApp<E>;
   defaultAppOptions?: HonoOptions<E>;
 }) => Factory<E, P>;
+/**
+ * `defineMiddleware()` defines a middleware with the types.
+ *
+ * @see {@link https://hono.dev/docs/helpers/factory#definemiddleware}
+ *
+ * @example
+ * ```ts
+ * const auth = defineMiddleware<{ Variables: { user: User } }>(async (c, next) => {
+ *   c.set('user', await getUser(c))
+ *   await next()
+ * })
+ * ```
+ */
+export declare const defineMiddleware: <E extends Env = any, P extends string = string, I extends Input = {}, R extends HandlerResponse<any> | void = void>(middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>) => MiddlewareHandler<E, P, I, R extends void ? Response : R>;
+/**
+ * @deprecated Use `defineMiddleware()` instead. It will be removed in the next major version.
+ */
 export declare const createMiddleware: <E extends Env = any, P extends string = string, I extends Input = {}, R extends HandlerResponse<any> | void = void>(middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>) => MiddlewareHandler<E, P, I, R extends void ? Response : R>;
 //#endregion
+export { type StandardSchema, type ValidationFailure, type ValidationIssue, defineHandler };
 export {};

package/dist/helper/factory/index.js

@@ -1,9 +1,6 @@
 import { Hono } from "../../hono.js";
+import { defineHandler } from "./define-handler.js";
 //#region src/helper/factory/index.ts
-/**
-* @module
-* Factory Helper for Hono.
-*/
 var Factory = class {
 	initApp;
 	#defaultAppOptions;
@@ -19,12 +16,15 @@ var Factory = class {
 		if (this.initApp) this.initApp(app);
 		return app;
 	};
-	createMiddleware = (middleware) => middleware;
+	defineMiddleware = (middleware) => middleware;
+	defineHandler = defineHandler;
+	createMiddleware = this.defineMiddleware;
 	createHandlers = (...handlers) => {
 		return handlers.filter((handler) => handler !== void 0);
 	};
 };
 const createFactory = (init) => new Factory(init);
-const createMiddleware = (middleware) => middleware;
+const defineMiddleware = (middleware) => middleware;
+const createMiddleware = defineMiddleware;
 //#endregion
-export { Factory, createFactory, createMiddleware };
+export { Factory, createFactory, createMiddleware, defineHandler, defineMiddleware };

package/dist/helper/html/index.js

@@ -1,9 +1,5 @@
 import { escapeToBuffer, raw, resolveCallbackSync, stringBufferToString } from "../../utils/html.js";
 //#region src/helper/html/index.ts
-/**
-* @module
-* html Helper for Hono.
-*/
 const html = (strings, ...values) => {
 	const buffer = [""];
 	for (let i = 0, len = strings.length - 1; i < len; i++) {

package/dist/helper/proxy/index.js

@@ -1,9 +1,5 @@
 import { HTTPException } from "../../http-exception.js";
 //#region src/helper/proxy/index.ts
-/**
-* @module
-* Proxy Helper for Hono.
-*/
 const hopByHopHeaders = [
 	"connection",
 	"keep-alive",
@@ -48,51 +44,6 @@ const preprocessRequestInit = (requestInit) => {
 	requestInit.headers = headers;
 	return requestInit;
 };
-/**
-* Fetch API wrapper for proxy.
-* The parameters and return value are the same as for `fetch` (except for the proxy-specific options).
-*
-* The "Accept-Encoding" header is replaced with an encoding that the current runtime can handle.
-* Unnecessary response headers are deleted and a Response object is returned that can be returned
-* as is as a response from the handler.
-*
-* @example
-* ```ts
-* app.get('/proxy/:path', (c) => {
-*   return proxy(`http://${originServer}/${c.req.param('path')}`, {
-*     headers: {
-*       ...c.req.header(), // optional, specify only when forwarding all the request data (including credentials) is necessary.
-*       'X-Forwarded-For': '127.0.0.1',
-*       'X-Forwarded-Host': c.req.header('host'),
-*       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
-*     },
-*   }).then((res) => {
-*     res.headers.delete('Set-Cookie')
-*     return res
-*   })
-* })
-*
-* app.all('/proxy/:path', (c) => {
-*   return proxy(`http://${originServer}/${c.req.param('path')}`, {
-*     ...c.req, // optional, specify only when forwarding all the request data (including credentials) is necessary.
-*     headers: {
-*       ...c.req.header(),
-*       'X-Forwarded-For': '127.0.0.1',
-*       'X-Forwarded-Host': c.req.header('host'),
-*       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
-*     },
-*   })
-* })
-*
-* // Strict RFC compliance mode (use only in trusted environments)
-* app.get('/internal-proxy/:path', (c) => {
-*   return proxy(`http://${internalServer}/${c.req.param('path')}`, {
-*     ...c.req,
-*     strictConnectionProcessing: true,
-*   })
-* })
-* ```
-*/
 const proxy = async (input, proxyInit) => {
 	const { raw, customFetch, strictConnectionProcessing = false, ...requestInit } = proxyInit instanceof Request ? { raw: proxyInit } : proxyInit ?? {};
 	const req = new Request(input, {

package/dist/helper/route/index.js

@@ -1,99 +1,9 @@
 import { GET_MATCH_RESULT } from "../../request/constants.js";
 import { getPattern, splitRoutingPath } from "../../utils/url.js";
 //#region src/helper/route/index.ts
-/**
-* Get matched routes in the handler
-*
-* @param {Context} c - The context object
-* @returns An array of matched routes
-*
-* @example
-* ```ts
-* import { matchedRoutes } from 'hono/route'
-*
-* app.use('*', async function logger(c, next) {
-*   await next()
-*   matchedRoutes(c).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' : ''
-*     )
-*   })
-* })
-* ```
-*/
 const matchedRoutes = (c) => c.req[GET_MATCH_RESULT][0].map(([[, route]]) => route);
-/**
-* Get the route path registered within the handler
-*
-* @param {Context} c - The context object
-* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
-* @returns The route path registered within the handler
-*
-* @example
-* ```ts
-* import { routePath } from 'hono/route'
-*
-* app.use('*', (c, next) => {
-*   console.log(routePath(c)) // '*'
-*   console.log(routePath(c, -1)) // '/posts/:id'
-*   return next()
-* })
-*
-* app.get('/posts/:id', (c) => {
-*   return c.text(routePath(c)) // '/posts/:id'
-* })
-* ```
-*/
 const routePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.path ?? "";
-/**
-* Get the basePath of the as-is route specified by routing.
-*
-* @param {Context} c - The context object
-* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
-* @returns The basePath of the as-is route specified by routing.
-*
-* @example
-* ```ts
-* import { baseRoutePath } from 'hono/route'
-*
-* const app = new Hono()
-*
-* const subApp = new Hono()
-* subApp.get('/posts/:id', (c) => {
-*   return c.text(baseRoutePath(c)) // '/:sub'
-* })
-*
-* app.route('/:sub', subApp)
-* ```
-*/
 const baseRoutePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.basePath ?? "";
-/**
-* Get the basePath with embedded parameters
-*
-* @param {Context} c - The context object
-* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
-* @returns The basePath with embedded parameters.
-*
-* @example
-* ```ts
-* import { basePath } from 'hono/route'
-*
-* const app = new Hono()
-*
-* const subApp = new Hono()
-* subApp.get('/posts/:id', (c) => {
-*   return c.text(basePath(c)) // '/requested-sub-app-path'
-* })
-*
-* app.route('/:sub', subApp)
-* ```
-*/
 const basePathCacheMap = /* @__PURE__ */ new WeakMap();
 const basePath = (c, index) => {
 	index ??= c.req.routeIndex;

package/dist/{types/helper → helper}/ssg/middleware.d.ts

@@ -3,12 +3,6 @@ import { Context } from "../../context.js";
 //#region src/helper/ssg/middleware.d.ts
 export declare const SSG_CONTEXT = "HONO_SSG_CONTEXT";
 export declare const X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
-/**
- * @deprecated
- * Use `X_HONO_DISABLE_SSG_HEADER_KEY` instead.
- * This constant will be removed in the next minor version.
- */
-export declare const SSG_DISABLED_RESPONSE: Response;
 interface SSGParam {
   [key: string]: string;
 }

package/dist/helper/ssg/middleware.js

@@ -2,24 +2,6 @@ import { isDynamicRoute } from "./utils.js";
 //#region src/helper/ssg/middleware.ts
 const SSG_CONTEXT = "HONO_SSG_CONTEXT";
 const X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
-/**
-* @deprecated
-* Use `X_HONO_DISABLE_SSG_HEADER_KEY` instead.
-* This constant will be removed in the next minor version.
-*/
-const SSG_DISABLED_RESPONSE = (() => {
-	try {
-		return new Response("SSG is disabled", {
-			status: 404,
-			headers: { [X_HONO_DISABLE_SSG_HEADER_KEY]: "true" }
-		});
-	} catch {
-		return null;
-	}
-})();
-/**
-* Define SSG Route
-*/
 const ssgParams = (params) => async (c, next) => {
 	if (isDynamicRoute(c.req.path)) {
 		c.req.raw.ssgParams = Array.isArray(params) ? params : await params(c);
@@ -27,17 +9,7 @@ const ssgParams = (params) => async (c, next) => {
 	}
 	await next();
 };
-/**
-* @experimental
-* `isSSGContext` is an experimental feature.
-* The API might be changed.
-*/
 const isSSGContext = (c) => !!c.env?.[SSG_CONTEXT];
-/**
-* @experimental
-* `disableSSG` is an experimental feature.
-* The API might be changed.
-*/
 const disableSSG = () => async function disableSSG(c, next) {
 	if (isSSGContext(c)) {
 		c.header(X_HONO_DISABLE_SSG_HEADER_KEY, "true");
@@ -45,14 +17,9 @@ const disableSSG = () => async function disableSSG(c, next) {
 	}
 	await next();
 };
-/**
-* @experimental
-* `onlySSG` is an experimental feature.
-* The API might be changed.
-*/
 const onlySSG = () => async function onlySSG(c, next) {
 	if (!isSSGContext(c)) return c.notFound();
 	await next();
 };
 //#endregion
-export { SSG_CONTEXT, SSG_DISABLED_RESPONSE, X_HONO_DISABLE_SSG_HEADER_KEY, disableSSG, isSSGContext, onlySSG, ssgParams };
+export { SSG_CONTEXT, X_HONO_DISABLE_SSG_HEADER_KEY, disableSSG, isSSGContext, onlySSG, ssgParams };

package/dist/helper/ssg/plugins.js

@@ -1,12 +1,5 @@
 import { html } from "../html/index.js";
 //#region src/helper/ssg/plugins.ts
-/**
-* The default plugin that defines the recommended behavior.
-*
-* @experimental
-* `defaultPlugin` is an experimental feature.
-* The API might be changed.
-*/
 const defaultPlugin = () => {
 	return { afterResponseHook: (res) => {
 		if (res.status !== 200) return false;
@@ -31,23 +24,6 @@ const generateRedirectHtml = (location) => {
 </body>
 `.toString().replace(/\n/g, "");
 };
-/**
-* The redirect plugin that generates HTML redirect pages for HTTP redirect responses for status codes 301, 302, 303, 307 and 308.
-*
-* When used with `defaultPlugin`, place `redirectPlugin` before it, because `defaultPlugin` skips non-200 responses.
-*
-* ```ts
-* // ✅ Will work as expected
-* toSSG(app, fs, { plugins: [redirectPlugin(), defaultPlugin()] })
-*
-* // ❌ Will not work as expected
-* toSSG(app, fs, { plugins: [defaultPlugin(), redirectPlugin()] })
-* ```
-*
-* @experimental
-* `redirectPlugin` is an experimental feature.
-* The API might be changed.
-*/
 const redirectPlugin = () => {
 	return { afterResponseHook: (res) => {
 		if (REDIRECT_STATUS_CODES.has(res.status)) {

package/dist/{types/helper → helper}/ssg/ssg.d.ts

@@ -37,18 +37,6 @@ export interface SSGPlugin {
 }
 export interface ToSSGOptions {
   dir?: string;
-  /**
-   * @deprecated Use plugins[].beforeRequestHook instead.
-   */
-  beforeRequestHook?: BeforeRequestHook | BeforeRequestHook[];
-  /**
-   * @deprecated Use plugins[].afterResponseHook instead.
-   */
-  afterResponseHook?: AfterResponseHook | AfterResponseHook[];
-  /**
-   * @deprecated Use plugins[].afterGenerateHook instead.
-   */
-  afterGenerateHook?: AfterGenerateHook | AfterGenerateHook[];
   concurrency?: number;
   extensionMap?: Record<string, string>;
   plugins?: SSGPlugin[];