hono 4.6.4 → 4.6.6
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/adapter/deno/serve-static.js +4 -2
- package/dist/cjs/adapter/deno/serve-static.js +4 -2
- package/dist/cjs/client/client.js +10 -16
- package/dist/cjs/client/utils.js +18 -0
- package/dist/cjs/middleware/cors/index.js +6 -2
- package/dist/cjs/middleware/csrf/index.js +1 -1
- package/dist/cjs/middleware/powered-by/index.js +2 -2
- package/dist/cjs/middleware/secure-headers/secure-headers.js +6 -5
- package/dist/client/client.js +11 -16
- package/dist/client/utils.js +17 -0
- package/dist/middleware/cors/index.js +6 -2
- package/dist/middleware/csrf/index.js +1 -1
- package/dist/middleware/powered-by/index.js +2 -2
- package/dist/middleware/secure-headers/secure-headers.js +6 -5
- package/dist/types/adapter/cloudflare-pages/handler.d.ts +1 -1
- package/dist/types/adapter/lambda-edge/handler.d.ts +2 -2
- package/dist/types/client/types.d.ts +18 -8
- package/dist/types/client/utils.d.ts +1 -0
- package/dist/types/compose.d.ts +7 -1
- package/dist/types/context.d.ts +26 -16
- package/dist/types/helper/accepts/accepts.d.ts +1 -1
- package/dist/types/helper/adapter/index.d.ts +1 -1
- package/dist/types/helper/conninfo/types.d.ts +2 -2
- package/dist/types/helper/css/common.d.ts +6 -1
- package/dist/types/helper/factory/index.d.ts +31 -10
- package/dist/types/helper/ssg/ssg.d.ts +1 -1
- package/dist/types/helper/websocket/index.d.ts +1 -1
- package/dist/types/hono-base.d.ts +19 -22
- package/dist/types/hono.d.ts +1 -1
- package/dist/types/jsx/base.d.ts +4 -1
- package/dist/types/jsx/dom/hooks/index.d.ts +9 -3
- package/dist/types/jsx/dom/index.d.ts +28 -7
- package/dist/types/jsx/dom/intrinsic-element/components.d.ts +6 -6
- package/dist/types/jsx/dom/render.d.ts +28 -4
- package/dist/types/jsx/dom/server.d.ts +28 -7
- package/dist/types/jsx/hooks/index.d.ts +20 -5
- package/dist/types/jsx/index.d.ts +28 -7
- package/dist/types/jsx/intrinsic-element/components.d.ts +4 -4
- package/dist/types/jsx/intrinsic-elements.d.ts +46 -46
- package/dist/types/middleware/compress/index.d.ts +4 -1
- package/dist/types/middleware/powered-by/index.d.ts +24 -1
- package/dist/types/middleware/secure-headers/permissions-policy.d.ts +3 -3
- package/dist/types/middleware/secure-headers/secure-headers.d.ts +1 -1
- package/dist/types/preset/quick.d.ts +1 -1
- package/dist/types/preset/tiny.d.ts +1 -1
- package/dist/types/request.d.ts +5 -7
- package/dist/types/router/linear-router/router.d.ts +5 -1
- package/dist/types/router/pattern-router/router.d.ts +0 -1
- package/dist/types/router/reg-exp-router/node.d.ts +4 -1
- package/dist/types/router/reg-exp-router/router.d.ts +4 -3
- package/dist/types/router/reg-exp-router/trie.d.ts +5 -1
- package/dist/types/router/smart-router/router.d.ts +6 -2
- package/dist/types/router/trie-router/node.d.ts +6 -2
- package/dist/types/router.d.ts +20 -2
- package/dist/types/types.d.ts +908 -120
- package/dist/types/utils/cookie.d.ts +3 -3
- package/dist/types/utils/html.d.ts +6 -2
- package/dist/types/utils/jwt/jwt.d.ts +1 -1
- package/dist/types/utils/mime.d.ts +1 -1
- package/dist/types/utils/stream.d.ts +0 -4
- package/dist/types/utils/url.d.ts +5 -1
- package/dist/types/validator/validator.d.ts +18 -6
- package/package.json +8 -7
package/dist/types/types.d.ts
CHANGED
|
@@ -14,7 +14,7 @@ export type Env = {
|
|
|
14
14
|
Variables?: Variables;
|
|
15
15
|
};
|
|
16
16
|
export type Next = () => Promise<void>;
|
|
17
|
-
export type ExtractInput<I extends Input | Input[
|
|
17
|
+
export type ExtractInput<I extends Input | Input["in"]> = I extends Input ? unknown extends I["in"] ? {} : I["in"] : I;
|
|
18
18
|
export type Input = {
|
|
19
19
|
in?: {};
|
|
20
20
|
out?: {};
|
|
@@ -36,37 +36,146 @@ export interface HTTPResponseError extends Error {
|
|
|
36
36
|
getResponse: () => Response;
|
|
37
37
|
}
|
|
38
38
|
export type ErrorHandler<E extends Env = any> = (err: Error | HTTPResponseError, c: Context<E>) => Response | Promise<Response>;
|
|
39
|
-
export interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = BlankSchema, BasePath extends string =
|
|
40
|
-
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler: H<E2, P, I, R>): Hono<IntersectNonAnyTypes<[
|
|
41
|
-
|
|
39
|
+
export interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = BlankSchema, BasePath extends string = "/"> {
|
|
40
|
+
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler: H<E2, P, I, R>): Hono<IntersectNonAnyTypes<[
|
|
41
|
+
E,
|
|
42
|
+
E2
|
|
43
|
+
]>, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath>;
|
|
44
|
+
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, I extends Input = BlankInput, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
|
|
45
|
+
E,
|
|
46
|
+
E2
|
|
47
|
+
]>>(...handlers: [
|
|
48
|
+
H<E2, P, I>,
|
|
49
|
+
H<E3, P, I2, R>
|
|
50
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
51
|
+
E,
|
|
52
|
+
E2,
|
|
53
|
+
E3
|
|
54
|
+
]>, S & ToSchema<M, P, I2, MergeTypedResponse<R>>, BasePath>;
|
|
42
55
|
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(path: P, handler: H<E2, MergedPath, I, R>): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
|
|
43
|
-
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
56
|
+
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
|
|
57
|
+
E,
|
|
58
|
+
E2,
|
|
59
|
+
E3
|
|
60
|
+
]>>(...handlers: [
|
|
61
|
+
H<E2, P, I>,
|
|
62
|
+
H<E3, P, I2>,
|
|
63
|
+
H<E4, P, I3, R>
|
|
64
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
65
|
+
E,
|
|
66
|
+
E2,
|
|
67
|
+
E3,
|
|
68
|
+
E4
|
|
69
|
+
]>, S & ToSchema<M, P, I3, MergeTypedResponse<R>>, BasePath>;
|
|
70
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
|
|
71
|
+
E,
|
|
72
|
+
E2
|
|
73
|
+
]>>(path: P, ...handlers: [
|
|
74
|
+
H<E2, MergedPath, I>,
|
|
75
|
+
H<E3, MergedPath, I2, R>
|
|
76
|
+
]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
|
|
77
|
+
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[
|
|
78
|
+
E,
|
|
79
|
+
E2,
|
|
80
|
+
E3,
|
|
81
|
+
E4
|
|
82
|
+
]>>(...handlers: [
|
|
83
|
+
H<E2, P, I>,
|
|
84
|
+
H<E3, P, I2>,
|
|
85
|
+
H<E4, P, I3>,
|
|
86
|
+
H<E5, P, I4, R>
|
|
87
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
88
|
+
E,
|
|
89
|
+
E2,
|
|
90
|
+
E3,
|
|
91
|
+
E4,
|
|
92
|
+
E5
|
|
93
|
+
]>, S & ToSchema<M, P, I4, MergeTypedResponse<R>>, BasePath>;
|
|
94
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
|
|
95
|
+
E,
|
|
96
|
+
E2,
|
|
97
|
+
E3
|
|
98
|
+
]>>(path: P, ...handlers: [
|
|
99
|
+
H<E2, MergedPath, I>,
|
|
100
|
+
H<E3, MergedPath, I2>,
|
|
101
|
+
H<E4, MergedPath, I3, R>
|
|
102
|
+
]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
|
|
103
|
+
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[
|
|
104
|
+
E,
|
|
105
|
+
E2,
|
|
106
|
+
E3,
|
|
107
|
+
E4,
|
|
108
|
+
E5
|
|
109
|
+
]>>(...handlers: [
|
|
110
|
+
H<E2, P, I>,
|
|
111
|
+
H<E3, P, I2>,
|
|
112
|
+
H<E4, P, I3>,
|
|
113
|
+
H<E5, P, I4>,
|
|
114
|
+
H<E6, P, I5, R>
|
|
115
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
116
|
+
E,
|
|
117
|
+
E2,
|
|
118
|
+
E3,
|
|
119
|
+
E4,
|
|
120
|
+
E5,
|
|
121
|
+
E6
|
|
122
|
+
]>, S & ToSchema<M, P, I5, MergeTypedResponse<R>>, BasePath>;
|
|
123
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[
|
|
124
|
+
E,
|
|
125
|
+
E2,
|
|
126
|
+
E3,
|
|
127
|
+
E4
|
|
128
|
+
]>>(path: P, ...handlers: [
|
|
49
129
|
H<E2, MergedPath, I>,
|
|
50
130
|
H<E3, MergedPath, I2>,
|
|
51
131
|
H<E4, MergedPath, I3>,
|
|
52
132
|
H<E5, MergedPath, I4, R>
|
|
53
133
|
]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
|
|
54
|
-
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
|
|
134
|
+
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
|
|
135
|
+
E,
|
|
136
|
+
E2,
|
|
137
|
+
E3,
|
|
138
|
+
E4,
|
|
139
|
+
E5,
|
|
140
|
+
E6
|
|
141
|
+
]>>(...handlers: [
|
|
55
142
|
H<E2, P, I>,
|
|
56
143
|
H<E3, P, I2>,
|
|
57
144
|
H<E4, P, I3>,
|
|
58
145
|
H<E5, P, I4>,
|
|
59
146
|
H<E6, P, I5>,
|
|
60
147
|
H<E7, P, I6, R>
|
|
61
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
62
|
-
|
|
148
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
149
|
+
E,
|
|
150
|
+
E2,
|
|
151
|
+
E3,
|
|
152
|
+
E4,
|
|
153
|
+
E5,
|
|
154
|
+
E6,
|
|
155
|
+
E7
|
|
156
|
+
]>, S & ToSchema<M, P, I6, MergeTypedResponse<R>>, BasePath>;
|
|
157
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[
|
|
158
|
+
E,
|
|
159
|
+
E2,
|
|
160
|
+
E3,
|
|
161
|
+
E4,
|
|
162
|
+
E5
|
|
163
|
+
]>>(path: P, ...handlers: [
|
|
63
164
|
H<E2, MergedPath, I>,
|
|
64
165
|
H<E3, MergedPath, I2>,
|
|
65
166
|
H<E4, MergedPath, I3>,
|
|
66
167
|
H<E5, MergedPath, I4>,
|
|
67
168
|
H<E6, MergedPath, I5, R>
|
|
68
169
|
]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
|
|
69
|
-
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
|
|
170
|
+
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
|
|
171
|
+
E,
|
|
172
|
+
E2,
|
|
173
|
+
E3,
|
|
174
|
+
E4,
|
|
175
|
+
E5,
|
|
176
|
+
E6,
|
|
177
|
+
E7
|
|
178
|
+
]>>(...handlers: [
|
|
70
179
|
H<E2, P, I>,
|
|
71
180
|
H<E3, P, I2>,
|
|
72
181
|
H<E4, P, I3>,
|
|
@@ -74,8 +183,24 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
|
|
|
74
183
|
H<E6, P, I5>,
|
|
75
184
|
H<E7, P, I6>,
|
|
76
185
|
H<E8, P, I7, R>
|
|
77
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
78
|
-
|
|
186
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
187
|
+
E,
|
|
188
|
+
E2,
|
|
189
|
+
E3,
|
|
190
|
+
E4,
|
|
191
|
+
E5,
|
|
192
|
+
E6,
|
|
193
|
+
E7,
|
|
194
|
+
E8
|
|
195
|
+
]>, S & ToSchema<M, P, I7, MergeTypedResponse<R>>, BasePath>;
|
|
196
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
|
|
197
|
+
E,
|
|
198
|
+
E2,
|
|
199
|
+
E3,
|
|
200
|
+
E4,
|
|
201
|
+
E5,
|
|
202
|
+
E6
|
|
203
|
+
]>>(path: P, ...handlers: [
|
|
79
204
|
H<E2, MergedPath, I>,
|
|
80
205
|
H<E3, MergedPath, I2>,
|
|
81
206
|
H<E4, MergedPath, I3>,
|
|
@@ -83,7 +208,16 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
|
|
|
83
208
|
H<E6, MergedPath, I5>,
|
|
84
209
|
H<E7, MergedPath, I6, R>
|
|
85
210
|
]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
|
|
86
|
-
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
|
|
211
|
+
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
|
|
212
|
+
E,
|
|
213
|
+
E2,
|
|
214
|
+
E3,
|
|
215
|
+
E4,
|
|
216
|
+
E5,
|
|
217
|
+
E6,
|
|
218
|
+
E7,
|
|
219
|
+
E8
|
|
220
|
+
]>>(...handlers: [
|
|
87
221
|
H<E2, P, I>,
|
|
88
222
|
H<E3, P, I2>,
|
|
89
223
|
H<E4, P, I3>,
|
|
@@ -92,8 +226,26 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
|
|
|
92
226
|
H<E7, P, I6>,
|
|
93
227
|
H<E8, P, I7>,
|
|
94
228
|
H<E9, P, I8, R>
|
|
95
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
96
|
-
|
|
229
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
230
|
+
E,
|
|
231
|
+
E2,
|
|
232
|
+
E3,
|
|
233
|
+
E4,
|
|
234
|
+
E5,
|
|
235
|
+
E6,
|
|
236
|
+
E7,
|
|
237
|
+
E8,
|
|
238
|
+
E9
|
|
239
|
+
]>, S & ToSchema<M, P, I8, MergeTypedResponse<R>>, BasePath>;
|
|
240
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
|
|
241
|
+
E,
|
|
242
|
+
E2,
|
|
243
|
+
E3,
|
|
244
|
+
E4,
|
|
245
|
+
E5,
|
|
246
|
+
E6,
|
|
247
|
+
E7
|
|
248
|
+
]>>(path: P, ...handlers: [
|
|
97
249
|
H<E2, MergedPath, I>,
|
|
98
250
|
H<E3, MergedPath, I2>,
|
|
99
251
|
H<E4, MergedPath, I3>,
|
|
@@ -102,7 +254,17 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
|
|
|
102
254
|
H<E7, MergedPath, I6>,
|
|
103
255
|
H<E8, MergedPath, I7, R>
|
|
104
256
|
]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
|
|
105
|
-
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
|
|
257
|
+
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
|
|
258
|
+
E,
|
|
259
|
+
E2,
|
|
260
|
+
E3,
|
|
261
|
+
E4,
|
|
262
|
+
E5,
|
|
263
|
+
E6,
|
|
264
|
+
E7,
|
|
265
|
+
E8,
|
|
266
|
+
E9
|
|
267
|
+
]>>(...handlers: [
|
|
106
268
|
H<E2, P, I>,
|
|
107
269
|
H<E3, P, I2>,
|
|
108
270
|
H<E4, P, I3>,
|
|
@@ -112,8 +274,28 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
|
|
|
112
274
|
H<E8, P, I7>,
|
|
113
275
|
H<E9, P, I8>,
|
|
114
276
|
H<E10, P, I9, R>
|
|
115
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
116
|
-
|
|
277
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
278
|
+
E,
|
|
279
|
+
E2,
|
|
280
|
+
E3,
|
|
281
|
+
E4,
|
|
282
|
+
E5,
|
|
283
|
+
E6,
|
|
284
|
+
E7,
|
|
285
|
+
E8,
|
|
286
|
+
E9,
|
|
287
|
+
E10
|
|
288
|
+
]>, S & ToSchema<M, P, I9, MergeTypedResponse<R>>, BasePath>;
|
|
289
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
|
|
290
|
+
E,
|
|
291
|
+
E2,
|
|
292
|
+
E3,
|
|
293
|
+
E4,
|
|
294
|
+
E5,
|
|
295
|
+
E6,
|
|
296
|
+
E7,
|
|
297
|
+
E8
|
|
298
|
+
]>>(path: P, ...handlers: [
|
|
117
299
|
H<E2, MergedPath, I>,
|
|
118
300
|
H<E3, MergedPath, I2>,
|
|
119
301
|
H<E4, MergedPath, I3>,
|
|
@@ -123,7 +305,18 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
|
|
|
123
305
|
H<E8, MergedPath, I7>,
|
|
124
306
|
H<E9, MergedPath, I8, R>
|
|
125
307
|
]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
|
|
126
|
-
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[
|
|
308
|
+
<P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[
|
|
309
|
+
E,
|
|
310
|
+
E2,
|
|
311
|
+
E3,
|
|
312
|
+
E4,
|
|
313
|
+
E5,
|
|
314
|
+
E6,
|
|
315
|
+
E7,
|
|
316
|
+
E8,
|
|
317
|
+
E9,
|
|
318
|
+
E10
|
|
319
|
+
]>>(...handlers: [
|
|
127
320
|
H<E2, P, I>,
|
|
128
321
|
H<E3, P, I2>,
|
|
129
322
|
H<E4, P, I3>,
|
|
@@ -134,8 +327,30 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
|
|
|
134
327
|
H<E9, P, I8>,
|
|
135
328
|
H<E10, P, I9>,
|
|
136
329
|
H<E11, P, I10, R>
|
|
137
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
138
|
-
|
|
330
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
331
|
+
E,
|
|
332
|
+
E2,
|
|
333
|
+
E3,
|
|
334
|
+
E4,
|
|
335
|
+
E5,
|
|
336
|
+
E6,
|
|
337
|
+
E7,
|
|
338
|
+
E8,
|
|
339
|
+
E9,
|
|
340
|
+
E10,
|
|
341
|
+
E11
|
|
342
|
+
]>, S & ToSchema<M, P, I10, MergeTypedResponse<R>>, BasePath>;
|
|
343
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
|
|
344
|
+
E,
|
|
345
|
+
E2,
|
|
346
|
+
E3,
|
|
347
|
+
E4,
|
|
348
|
+
E5,
|
|
349
|
+
E6,
|
|
350
|
+
E7,
|
|
351
|
+
E8,
|
|
352
|
+
E9
|
|
353
|
+
]>>(path: P, ...handlers: [
|
|
139
354
|
H<E2, MergedPath, I>,
|
|
140
355
|
H<E3, MergedPath, I2>,
|
|
141
356
|
H<E4, MergedPath, I3>,
|
|
@@ -146,7 +361,18 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
|
|
|
146
361
|
H<E9, MergedPath, I8>,
|
|
147
362
|
H<E10, MergedPath, I9, R>
|
|
148
363
|
]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
|
|
149
|
-
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[
|
|
364
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[
|
|
365
|
+
E,
|
|
366
|
+
E2,
|
|
367
|
+
E3,
|
|
368
|
+
E4,
|
|
369
|
+
E5,
|
|
370
|
+
E6,
|
|
371
|
+
E7,
|
|
372
|
+
E8,
|
|
373
|
+
E9,
|
|
374
|
+
E10
|
|
375
|
+
]>>(path: P, ...handlers: [
|
|
150
376
|
H<E2, MergedPath, I>,
|
|
151
377
|
H<E3, MergedPath, I2>,
|
|
152
378
|
H<E4, MergedPath, I3>,
|
|
@@ -162,49 +388,175 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
|
|
|
162
388
|
<P extends string, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
|
|
163
389
|
<P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(path: P): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
|
|
164
390
|
}
|
|
165
|
-
export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string =
|
|
166
|
-
<E2 extends Env = E>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, ExtractStringKey<S>>>[]): Hono<IntersectNonAnyTypes<[
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
<E2 extends Env = E
|
|
171
|
-
|
|
172
|
-
|
|
391
|
+
export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = "/"> {
|
|
392
|
+
<E2 extends Env = E>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, ExtractStringKey<S>>>[]): Hono<IntersectNonAnyTypes<[
|
|
393
|
+
E,
|
|
394
|
+
E2
|
|
395
|
+
]>, S, BasePath>;
|
|
396
|
+
<E2 extends Env = E>(handler: MiddlewareHandler<E2, MergePath<BasePath, ExtractStringKey<S>>>): Hono<IntersectNonAnyTypes<[
|
|
397
|
+
E,
|
|
398
|
+
E2
|
|
399
|
+
]>, S, BasePath>;
|
|
400
|
+
<E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
|
|
401
|
+
E,
|
|
402
|
+
E2
|
|
403
|
+
]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
|
|
404
|
+
MiddlewareHandler<E2, P>,
|
|
405
|
+
MiddlewareHandler<E3, P>
|
|
406
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
407
|
+
E,
|
|
408
|
+
E2,
|
|
409
|
+
E3
|
|
410
|
+
]>, S, BasePath>;
|
|
411
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E>(path: P, handler: MiddlewareHandler<E2, MergedPath>): Hono<IntersectNonAnyTypes<[
|
|
412
|
+
E,
|
|
413
|
+
E2
|
|
414
|
+
]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
|
|
415
|
+
<E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
|
|
416
|
+
E,
|
|
417
|
+
E2,
|
|
418
|
+
E3
|
|
419
|
+
]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
|
|
420
|
+
MiddlewareHandler<E2, P>,
|
|
421
|
+
MiddlewareHandler<E3, P>,
|
|
422
|
+
MiddlewareHandler<E4, P>
|
|
423
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
424
|
+
E,
|
|
425
|
+
E2,
|
|
426
|
+
E3,
|
|
427
|
+
E4
|
|
428
|
+
]>, S, BasePath>;
|
|
429
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
|
|
430
|
+
E,
|
|
431
|
+
E2
|
|
432
|
+
]>>(path: P, ...handlers: [
|
|
433
|
+
MiddlewareHandler<E2, P>,
|
|
434
|
+
MiddlewareHandler<E3, P>
|
|
435
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
436
|
+
E,
|
|
437
|
+
E2,
|
|
438
|
+
E3
|
|
439
|
+
]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
|
|
440
|
+
<E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[
|
|
441
|
+
E,
|
|
442
|
+
E2,
|
|
443
|
+
E3,
|
|
444
|
+
E4
|
|
445
|
+
]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
|
|
173
446
|
MiddlewareHandler<E2, P>,
|
|
174
447
|
MiddlewareHandler<E3, P>,
|
|
175
448
|
MiddlewareHandler<E4, P>,
|
|
176
449
|
MiddlewareHandler<E5, P>
|
|
177
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
178
|
-
|
|
179
|
-
|
|
450
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
451
|
+
E,
|
|
452
|
+
E2,
|
|
453
|
+
E3,
|
|
454
|
+
E4,
|
|
455
|
+
E5
|
|
456
|
+
]>, S, BasePath>;
|
|
457
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
|
|
458
|
+
E,
|
|
459
|
+
E2,
|
|
460
|
+
E3
|
|
461
|
+
]>>(path: P, ...handlers: [
|
|
462
|
+
MiddlewareHandler<E2, P>,
|
|
463
|
+
MiddlewareHandler<E3, P>,
|
|
464
|
+
MiddlewareHandler<E4, P>
|
|
465
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
466
|
+
E,
|
|
467
|
+
E2,
|
|
468
|
+
E3,
|
|
469
|
+
E4
|
|
470
|
+
]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
|
|
471
|
+
<E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[
|
|
472
|
+
E,
|
|
473
|
+
E2,
|
|
474
|
+
E3,
|
|
475
|
+
E4,
|
|
476
|
+
E5
|
|
477
|
+
]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
|
|
180
478
|
MiddlewareHandler<E2, P>,
|
|
181
479
|
MiddlewareHandler<E3, P>,
|
|
182
480
|
MiddlewareHandler<E4, P>,
|
|
183
481
|
MiddlewareHandler<E5, P>,
|
|
184
482
|
MiddlewareHandler<E6, P>
|
|
185
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
186
|
-
|
|
483
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
484
|
+
E,
|
|
485
|
+
E2,
|
|
486
|
+
E3,
|
|
487
|
+
E4,
|
|
488
|
+
E5,
|
|
489
|
+
E6
|
|
490
|
+
]>, S, BasePath>;
|
|
491
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[
|
|
492
|
+
E,
|
|
493
|
+
E2,
|
|
494
|
+
E3,
|
|
495
|
+
E4
|
|
496
|
+
]>>(path: P, ...handlers: [
|
|
187
497
|
MiddlewareHandler<E2, P>,
|
|
188
498
|
MiddlewareHandler<E3, P>,
|
|
189
499
|
MiddlewareHandler<E4, P>,
|
|
190
500
|
MiddlewareHandler<E5, P>
|
|
191
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
192
|
-
|
|
501
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
502
|
+
E,
|
|
503
|
+
E2,
|
|
504
|
+
E3,
|
|
505
|
+
E4,
|
|
506
|
+
E5
|
|
507
|
+
]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
|
|
508
|
+
<E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
|
|
509
|
+
E,
|
|
510
|
+
E2,
|
|
511
|
+
E3,
|
|
512
|
+
E4,
|
|
513
|
+
E5,
|
|
514
|
+
E6
|
|
515
|
+
]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
|
|
193
516
|
MiddlewareHandler<E2, P>,
|
|
194
517
|
MiddlewareHandler<E3, P>,
|
|
195
518
|
MiddlewareHandler<E4, P>,
|
|
196
519
|
MiddlewareHandler<E5, P>,
|
|
197
520
|
MiddlewareHandler<E6, P>,
|
|
198
521
|
MiddlewareHandler<E7, P>
|
|
199
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
200
|
-
|
|
522
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
523
|
+
E,
|
|
524
|
+
E2,
|
|
525
|
+
E3,
|
|
526
|
+
E4,
|
|
527
|
+
E5,
|
|
528
|
+
E6,
|
|
529
|
+
E7
|
|
530
|
+
]>, S, BasePath>;
|
|
531
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[
|
|
532
|
+
E,
|
|
533
|
+
E2,
|
|
534
|
+
E3,
|
|
535
|
+
E4,
|
|
536
|
+
E5
|
|
537
|
+
]>>(path: P, ...handlers: [
|
|
201
538
|
MiddlewareHandler<E2, P>,
|
|
202
539
|
MiddlewareHandler<E3, P>,
|
|
203
540
|
MiddlewareHandler<E4, P>,
|
|
204
541
|
MiddlewareHandler<E5, P>,
|
|
205
542
|
MiddlewareHandler<E6, P>
|
|
206
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
207
|
-
|
|
543
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
544
|
+
E,
|
|
545
|
+
E2,
|
|
546
|
+
E3,
|
|
547
|
+
E4,
|
|
548
|
+
E5,
|
|
549
|
+
E6
|
|
550
|
+
]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
|
|
551
|
+
<E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
|
|
552
|
+
E,
|
|
553
|
+
E2,
|
|
554
|
+
E3,
|
|
555
|
+
E4,
|
|
556
|
+
E5,
|
|
557
|
+
E6,
|
|
558
|
+
E7
|
|
559
|
+
]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
|
|
208
560
|
MiddlewareHandler<E2, P>,
|
|
209
561
|
MiddlewareHandler<E3, P>,
|
|
210
562
|
MiddlewareHandler<E4, P>,
|
|
@@ -212,16 +564,49 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
|
|
|
212
564
|
MiddlewareHandler<E6, P>,
|
|
213
565
|
MiddlewareHandler<E7, P>,
|
|
214
566
|
MiddlewareHandler<E8, P>
|
|
215
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
216
|
-
|
|
567
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
568
|
+
E,
|
|
569
|
+
E2,
|
|
570
|
+
E3,
|
|
571
|
+
E4,
|
|
572
|
+
E5,
|
|
573
|
+
E6,
|
|
574
|
+
E7,
|
|
575
|
+
E8
|
|
576
|
+
]>, S, BasePath>;
|
|
577
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
|
|
578
|
+
E,
|
|
579
|
+
E2,
|
|
580
|
+
E3,
|
|
581
|
+
E4,
|
|
582
|
+
E5,
|
|
583
|
+
E6
|
|
584
|
+
]>>(path: P, ...handlers: [
|
|
217
585
|
MiddlewareHandler<E2, P>,
|
|
218
586
|
MiddlewareHandler<E3, P>,
|
|
219
587
|
MiddlewareHandler<E4, P>,
|
|
220
588
|
MiddlewareHandler<E5, P>,
|
|
221
589
|
MiddlewareHandler<E6, P>,
|
|
222
590
|
MiddlewareHandler<E7, P>
|
|
223
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
224
|
-
|
|
591
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
592
|
+
E,
|
|
593
|
+
E2,
|
|
594
|
+
E3,
|
|
595
|
+
E4,
|
|
596
|
+
E5,
|
|
597
|
+
E6,
|
|
598
|
+
E7
|
|
599
|
+
]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
|
|
600
|
+
<E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
|
|
601
|
+
E,
|
|
602
|
+
E2,
|
|
603
|
+
E3,
|
|
604
|
+
E4,
|
|
605
|
+
E5,
|
|
606
|
+
E6,
|
|
607
|
+
E7,
|
|
608
|
+
E8
|
|
609
|
+
]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
|
|
225
610
|
MiddlewareHandler<E2, P>,
|
|
226
611
|
MiddlewareHandler<E3, P>,
|
|
227
612
|
MiddlewareHandler<E4, P>,
|
|
@@ -230,8 +615,26 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
|
|
|
230
615
|
MiddlewareHandler<E7, P>,
|
|
231
616
|
MiddlewareHandler<E8, P>,
|
|
232
617
|
MiddlewareHandler<E9, P>
|
|
233
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
234
|
-
|
|
618
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
619
|
+
E,
|
|
620
|
+
E2,
|
|
621
|
+
E3,
|
|
622
|
+
E4,
|
|
623
|
+
E5,
|
|
624
|
+
E6,
|
|
625
|
+
E7,
|
|
626
|
+
E8,
|
|
627
|
+
E9
|
|
628
|
+
]>, S, BasePath>;
|
|
629
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
|
|
630
|
+
E,
|
|
631
|
+
E2,
|
|
632
|
+
E3,
|
|
633
|
+
E4,
|
|
634
|
+
E5,
|
|
635
|
+
E6,
|
|
636
|
+
E7
|
|
637
|
+
]>>(path: P, ...handlers: [
|
|
235
638
|
MiddlewareHandler<E2, P>,
|
|
236
639
|
MiddlewareHandler<E3, P>,
|
|
237
640
|
MiddlewareHandler<E4, P>,
|
|
@@ -239,8 +642,27 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
|
|
|
239
642
|
MiddlewareHandler<E6, P>,
|
|
240
643
|
MiddlewareHandler<E7, P>,
|
|
241
644
|
MiddlewareHandler<E8, P>
|
|
242
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
243
|
-
|
|
645
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
646
|
+
E,
|
|
647
|
+
E2,
|
|
648
|
+
E3,
|
|
649
|
+
E4,
|
|
650
|
+
E5,
|
|
651
|
+
E6,
|
|
652
|
+
E7,
|
|
653
|
+
E8
|
|
654
|
+
]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
|
|
655
|
+
<E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
|
|
656
|
+
E,
|
|
657
|
+
E2,
|
|
658
|
+
E3,
|
|
659
|
+
E4,
|
|
660
|
+
E5,
|
|
661
|
+
E6,
|
|
662
|
+
E7,
|
|
663
|
+
E8,
|
|
664
|
+
E9
|
|
665
|
+
]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
|
|
244
666
|
MiddlewareHandler<E2, P>,
|
|
245
667
|
MiddlewareHandler<E3, P>,
|
|
246
668
|
MiddlewareHandler<E4, P>,
|
|
@@ -250,8 +672,28 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
|
|
|
250
672
|
MiddlewareHandler<E8, P>,
|
|
251
673
|
MiddlewareHandler<E9, P>,
|
|
252
674
|
MiddlewareHandler<E10, P>
|
|
253
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
254
|
-
|
|
675
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
676
|
+
E,
|
|
677
|
+
E2,
|
|
678
|
+
E3,
|
|
679
|
+
E4,
|
|
680
|
+
E5,
|
|
681
|
+
E6,
|
|
682
|
+
E7,
|
|
683
|
+
E8,
|
|
684
|
+
E9,
|
|
685
|
+
E10
|
|
686
|
+
]>, S, BasePath>;
|
|
687
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
|
|
688
|
+
E,
|
|
689
|
+
E2,
|
|
690
|
+
E3,
|
|
691
|
+
E4,
|
|
692
|
+
E5,
|
|
693
|
+
E6,
|
|
694
|
+
E7,
|
|
695
|
+
E8
|
|
696
|
+
]>>(path: P, ...handlers: [
|
|
255
697
|
MiddlewareHandler<E2, P>,
|
|
256
698
|
MiddlewareHandler<E3, P>,
|
|
257
699
|
MiddlewareHandler<E4, P>,
|
|
@@ -260,8 +702,29 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
|
|
|
260
702
|
MiddlewareHandler<E7, P>,
|
|
261
703
|
MiddlewareHandler<E8, P>,
|
|
262
704
|
MiddlewareHandler<E9, P>
|
|
263
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
264
|
-
|
|
705
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
706
|
+
E,
|
|
707
|
+
E2,
|
|
708
|
+
E3,
|
|
709
|
+
E4,
|
|
710
|
+
E5,
|
|
711
|
+
E6,
|
|
712
|
+
E7,
|
|
713
|
+
E8,
|
|
714
|
+
E9
|
|
715
|
+
]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
|
|
716
|
+
<E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[
|
|
717
|
+
E,
|
|
718
|
+
E2,
|
|
719
|
+
E3,
|
|
720
|
+
E4,
|
|
721
|
+
E5,
|
|
722
|
+
E6,
|
|
723
|
+
E7,
|
|
724
|
+
E8,
|
|
725
|
+
E9,
|
|
726
|
+
E10
|
|
727
|
+
]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
|
|
265
728
|
MiddlewareHandler<E2, P>,
|
|
266
729
|
MiddlewareHandler<E3, P>,
|
|
267
730
|
MiddlewareHandler<E4, P>,
|
|
@@ -272,8 +735,30 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
|
|
|
272
735
|
MiddlewareHandler<E9, P>,
|
|
273
736
|
MiddlewareHandler<E10, P>,
|
|
274
737
|
MiddlewareHandler<E11, P>
|
|
275
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
276
|
-
|
|
738
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
739
|
+
E,
|
|
740
|
+
E2,
|
|
741
|
+
E3,
|
|
742
|
+
E4,
|
|
743
|
+
E5,
|
|
744
|
+
E6,
|
|
745
|
+
E7,
|
|
746
|
+
E8,
|
|
747
|
+
E9,
|
|
748
|
+
E10,
|
|
749
|
+
E11
|
|
750
|
+
]>, S, BasePath>;
|
|
751
|
+
<P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
|
|
752
|
+
E,
|
|
753
|
+
E2,
|
|
754
|
+
E3,
|
|
755
|
+
E4,
|
|
756
|
+
E5,
|
|
757
|
+
E6,
|
|
758
|
+
E7,
|
|
759
|
+
E8,
|
|
760
|
+
E9
|
|
761
|
+
]>>(path: P, ...handlers: [
|
|
277
762
|
MiddlewareHandler<E2, P>,
|
|
278
763
|
MiddlewareHandler<E3, P>,
|
|
279
764
|
MiddlewareHandler<E4, P>,
|
|
@@ -283,35 +768,119 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
|
|
|
283
768
|
MiddlewareHandler<E8, P>,
|
|
284
769
|
MiddlewareHandler<E9, P>,
|
|
285
770
|
MiddlewareHandler<E10, P>
|
|
286
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
771
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
772
|
+
E,
|
|
773
|
+
E2,
|
|
774
|
+
E3,
|
|
775
|
+
E4,
|
|
776
|
+
E5,
|
|
777
|
+
E6,
|
|
778
|
+
E7,
|
|
779
|
+
E8,
|
|
780
|
+
E9,
|
|
781
|
+
E10
|
|
782
|
+
]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
|
|
287
783
|
<P extends string, E2 extends Env = E>(path: P, ...handlers: MiddlewareHandler<E2, MergePath<BasePath, P>>[]): Hono<E, S, BasePath>;
|
|
288
784
|
}
|
|
289
|
-
export interface OnHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string =
|
|
290
|
-
<M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(method: M, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
785
|
+
export interface OnHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = "/"> {
|
|
786
|
+
<M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(method: M, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[
|
|
787
|
+
E,
|
|
788
|
+
E2
|
|
789
|
+
]>, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
|
|
790
|
+
<M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
|
|
791
|
+
E,
|
|
792
|
+
E2
|
|
793
|
+
]>>(method: M, path: P, ...handlers: [
|
|
794
|
+
H<E2, MergedPath, I>,
|
|
795
|
+
H<E3, MergedPath, I2, R>
|
|
796
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
797
|
+
E,
|
|
798
|
+
E2,
|
|
799
|
+
E3
|
|
800
|
+
]>, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
|
|
801
|
+
<M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
|
|
802
|
+
E,
|
|
803
|
+
E2,
|
|
804
|
+
E3
|
|
805
|
+
]>>(method: M, path: P, ...handlers: [
|
|
806
|
+
H<E2, MergedPath, I>,
|
|
807
|
+
H<E3, MergedPath, I2>,
|
|
808
|
+
H<E4, MergedPath, I3, R>
|
|
809
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
810
|
+
E,
|
|
811
|
+
E2,
|
|
812
|
+
E3,
|
|
813
|
+
E4
|
|
814
|
+
]>, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
|
|
815
|
+
<M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[
|
|
816
|
+
E,
|
|
817
|
+
E2,
|
|
818
|
+
E3,
|
|
819
|
+
E4
|
|
820
|
+
]>>(method: M, path: P, ...handlers: [
|
|
294
821
|
H<E2, MergedPath, I>,
|
|
295
822
|
H<E3, MergedPath, I2>,
|
|
296
823
|
H<E4, MergedPath, I3>,
|
|
297
824
|
H<E5, MergedPath, I4, R>
|
|
298
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
299
|
-
|
|
825
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
826
|
+
E,
|
|
827
|
+
E2,
|
|
828
|
+
E3,
|
|
829
|
+
E4,
|
|
830
|
+
E5
|
|
831
|
+
]>, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
|
|
832
|
+
<M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[
|
|
833
|
+
E,
|
|
834
|
+
E2,
|
|
835
|
+
E3,
|
|
836
|
+
E4,
|
|
837
|
+
E5
|
|
838
|
+
]>>(method: M, path: P, ...handlers: [
|
|
300
839
|
H<E2, MergedPath, I>,
|
|
301
840
|
H<E3, MergedPath, I2>,
|
|
302
841
|
H<E4, MergedPath, I3>,
|
|
303
842
|
H<E5, MergedPath, I4>,
|
|
304
843
|
H<E6, MergedPath, I5, R>
|
|
305
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
306
|
-
|
|
844
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
845
|
+
E,
|
|
846
|
+
E2,
|
|
847
|
+
E3,
|
|
848
|
+
E4,
|
|
849
|
+
E5,
|
|
850
|
+
E6
|
|
851
|
+
]>, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
|
|
852
|
+
<M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
|
|
853
|
+
E,
|
|
854
|
+
E2,
|
|
855
|
+
E3,
|
|
856
|
+
E4,
|
|
857
|
+
E5,
|
|
858
|
+
E6
|
|
859
|
+
]>>(method: M, path: P, ...handlers: [
|
|
307
860
|
H<E2, MergedPath, I>,
|
|
308
861
|
H<E3, MergedPath, I2>,
|
|
309
862
|
H<E4, MergedPath, I3>,
|
|
310
863
|
H<E5, MergedPath, I4>,
|
|
311
864
|
H<E6, MergedPath, I5>,
|
|
312
865
|
H<E7, MergedPath, I6, R>
|
|
313
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
314
|
-
|
|
866
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
867
|
+
E,
|
|
868
|
+
E2,
|
|
869
|
+
E3,
|
|
870
|
+
E4,
|
|
871
|
+
E5,
|
|
872
|
+
E6,
|
|
873
|
+
E7
|
|
874
|
+
]>, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
|
|
875
|
+
<M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
|
|
876
|
+
E,
|
|
877
|
+
E2,
|
|
878
|
+
E3,
|
|
879
|
+
E4,
|
|
880
|
+
E5,
|
|
881
|
+
E6,
|
|
882
|
+
E7
|
|
883
|
+
]>>(method: M, path: P, ...handlers: [
|
|
315
884
|
H<E2, MergedPath, I>,
|
|
316
885
|
H<E3, MergedPath, I2>,
|
|
317
886
|
H<E4, MergedPath, I3>,
|
|
@@ -319,8 +888,26 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = Blan
|
|
|
319
888
|
H<E6, MergedPath, I5>,
|
|
320
889
|
H<E7, MergedPath, I6>,
|
|
321
890
|
H<E8, MergedPath, I7, R>
|
|
322
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
323
|
-
|
|
891
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
892
|
+
E,
|
|
893
|
+
E2,
|
|
894
|
+
E3,
|
|
895
|
+
E4,
|
|
896
|
+
E5,
|
|
897
|
+
E6,
|
|
898
|
+
E7,
|
|
899
|
+
E8
|
|
900
|
+
]>, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
|
|
901
|
+
<M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
|
|
902
|
+
E,
|
|
903
|
+
E2,
|
|
904
|
+
E3,
|
|
905
|
+
E4,
|
|
906
|
+
E5,
|
|
907
|
+
E6,
|
|
908
|
+
E7,
|
|
909
|
+
E8
|
|
910
|
+
]>>(method: M, path: P, ...handlers: [
|
|
324
911
|
H<E2, MergedPath, I>,
|
|
325
912
|
H<E3, MergedPath, I2>,
|
|
326
913
|
H<E4, MergedPath, I3>,
|
|
@@ -329,8 +916,28 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = Blan
|
|
|
329
916
|
H<E7, MergedPath, I6>,
|
|
330
917
|
H<E8, MergedPath, I7>,
|
|
331
918
|
H<E9, MergedPath, I8, R>
|
|
332
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
333
|
-
|
|
919
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
920
|
+
E,
|
|
921
|
+
E2,
|
|
922
|
+
E3,
|
|
923
|
+
E4,
|
|
924
|
+
E5,
|
|
925
|
+
E6,
|
|
926
|
+
E7,
|
|
927
|
+
E8,
|
|
928
|
+
E9
|
|
929
|
+
]>, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
|
|
930
|
+
<M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
|
|
931
|
+
E,
|
|
932
|
+
E2,
|
|
933
|
+
E3,
|
|
934
|
+
E4,
|
|
935
|
+
E5,
|
|
936
|
+
E6,
|
|
937
|
+
E7,
|
|
938
|
+
E8,
|
|
939
|
+
E9
|
|
940
|
+
]>>(method: M, path: P, ...handlers: [
|
|
334
941
|
H<E2, MergedPath, I>,
|
|
335
942
|
H<E3, MergedPath, I2>,
|
|
336
943
|
H<E4, MergedPath, I3>,
|
|
@@ -340,8 +947,30 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = Blan
|
|
|
340
947
|
H<E8, MergedPath, I7>,
|
|
341
948
|
H<E9, MergedPath, I8>,
|
|
342
949
|
H<E10, MergedPath, I9, R>
|
|
343
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
344
|
-
|
|
950
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
951
|
+
E,
|
|
952
|
+
E2,
|
|
953
|
+
E3,
|
|
954
|
+
E4,
|
|
955
|
+
E5,
|
|
956
|
+
E6,
|
|
957
|
+
E7,
|
|
958
|
+
E8,
|
|
959
|
+
E9,
|
|
960
|
+
E10
|
|
961
|
+
]>, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
|
|
962
|
+
<M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[
|
|
963
|
+
E,
|
|
964
|
+
E2,
|
|
965
|
+
E3,
|
|
966
|
+
E4,
|
|
967
|
+
E5,
|
|
968
|
+
E6,
|
|
969
|
+
E7,
|
|
970
|
+
E8,
|
|
971
|
+
E9,
|
|
972
|
+
E10
|
|
973
|
+
]>>(method: M, path: P, ...handlers: [
|
|
345
974
|
H<E2, MergedPath, I>,
|
|
346
975
|
H<E3, MergedPath, I2>,
|
|
347
976
|
H<E4, MergedPath, I3>,
|
|
@@ -352,33 +981,118 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = Blan
|
|
|
352
981
|
H<E9, MergedPath, I8>,
|
|
353
982
|
H<E10, MergedPath, I9>,
|
|
354
983
|
H<E11, MergedPath, I10>
|
|
355
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
984
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
985
|
+
E,
|
|
986
|
+
E2,
|
|
987
|
+
E3,
|
|
988
|
+
E4,
|
|
989
|
+
E5,
|
|
990
|
+
E6,
|
|
991
|
+
E7,
|
|
992
|
+
E8,
|
|
993
|
+
E9,
|
|
994
|
+
E10,
|
|
995
|
+
E11
|
|
996
|
+
]>, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
|
|
356
997
|
<M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(method: M, path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
|
|
357
|
-
<Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(methods: Ms, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
998
|
+
<Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(methods: Ms, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[
|
|
999
|
+
E,
|
|
1000
|
+
E2
|
|
1001
|
+
]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
|
|
1002
|
+
<Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
|
|
1003
|
+
E,
|
|
1004
|
+
E2
|
|
1005
|
+
]>>(methods: Ms, path: P, ...handlers: [
|
|
1006
|
+
H<E2, MergedPath, I>,
|
|
1007
|
+
H<E3, MergedPath, I2, R>
|
|
1008
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
1009
|
+
E,
|
|
1010
|
+
E2,
|
|
1011
|
+
E3
|
|
1012
|
+
]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
|
|
1013
|
+
<Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[
|
|
1014
|
+
E,
|
|
1015
|
+
E2,
|
|
1016
|
+
E3
|
|
1017
|
+
]>>(methods: Ms, path: P, ...handlers: [
|
|
1018
|
+
H<E2, MergedPath, I>,
|
|
1019
|
+
H<E3, MergedPath, I2>,
|
|
1020
|
+
H<E4, MergedPath, I3, R>
|
|
1021
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
1022
|
+
E,
|
|
1023
|
+
E2,
|
|
1024
|
+
E3,
|
|
1025
|
+
E4
|
|
1026
|
+
]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
|
|
1027
|
+
<Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[
|
|
1028
|
+
E,
|
|
1029
|
+
E2,
|
|
1030
|
+
E3,
|
|
1031
|
+
E4
|
|
1032
|
+
]>>(methods: Ms, path: P, ...handlers: [
|
|
361
1033
|
H<E2, MergedPath, I>,
|
|
362
1034
|
H<E3, MergedPath, I2>,
|
|
363
1035
|
H<E4, MergedPath, I3>,
|
|
364
1036
|
H<E5, MergedPath, I4, R>
|
|
365
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
366
|
-
|
|
1037
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
1038
|
+
E,
|
|
1039
|
+
E2,
|
|
1040
|
+
E3,
|
|
1041
|
+
E4,
|
|
1042
|
+
E5
|
|
1043
|
+
]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
|
|
1044
|
+
<Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[
|
|
1045
|
+
E,
|
|
1046
|
+
E2,
|
|
1047
|
+
E3,
|
|
1048
|
+
E4,
|
|
1049
|
+
E5
|
|
1050
|
+
]>>(methods: Ms, path: P, ...handlers: [
|
|
367
1051
|
H<E2, MergedPath, I>,
|
|
368
1052
|
H<E3, MergedPath, I2>,
|
|
369
1053
|
H<E4, MergedPath, I3>,
|
|
370
1054
|
H<E5, MergedPath, I4>,
|
|
371
1055
|
H<E6, MergedPath, I5, R>
|
|
372
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
373
|
-
|
|
1056
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
1057
|
+
E,
|
|
1058
|
+
E2,
|
|
1059
|
+
E3,
|
|
1060
|
+
E4,
|
|
1061
|
+
E5,
|
|
1062
|
+
E6
|
|
1063
|
+
]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
|
|
1064
|
+
<Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[
|
|
1065
|
+
E,
|
|
1066
|
+
E2,
|
|
1067
|
+
E3,
|
|
1068
|
+
E4,
|
|
1069
|
+
E5,
|
|
1070
|
+
E6
|
|
1071
|
+
]>>(methods: Ms, path: P, ...handlers: [
|
|
374
1072
|
H<E2, MergedPath, I>,
|
|
375
1073
|
H<E3, MergedPath, I2>,
|
|
376
1074
|
H<E4, MergedPath, I3>,
|
|
377
1075
|
H<E5, MergedPath, I4>,
|
|
378
1076
|
H<E6, MergedPath, I5>,
|
|
379
1077
|
H<E7, MergedPath, I6, R>
|
|
380
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
381
|
-
|
|
1078
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
1079
|
+
E,
|
|
1080
|
+
E2,
|
|
1081
|
+
E3,
|
|
1082
|
+
E4,
|
|
1083
|
+
E5,
|
|
1084
|
+
E6,
|
|
1085
|
+
E7
|
|
1086
|
+
]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
|
|
1087
|
+
<Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[
|
|
1088
|
+
E,
|
|
1089
|
+
E2,
|
|
1090
|
+
E3,
|
|
1091
|
+
E4,
|
|
1092
|
+
E5,
|
|
1093
|
+
E6,
|
|
1094
|
+
E7
|
|
1095
|
+
]>>(methods: Ms, path: P, ...handlers: [
|
|
382
1096
|
H<E2, MergedPath, I>,
|
|
383
1097
|
H<E3, MergedPath, I2>,
|
|
384
1098
|
H<E4, MergedPath, I3>,
|
|
@@ -386,8 +1100,26 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = Blan
|
|
|
386
1100
|
H<E6, MergedPath, I5>,
|
|
387
1101
|
H<E7, MergedPath, I6>,
|
|
388
1102
|
H<E8, MergedPath, I7, R>
|
|
389
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
390
|
-
|
|
1103
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
1104
|
+
E,
|
|
1105
|
+
E2,
|
|
1106
|
+
E3,
|
|
1107
|
+
E4,
|
|
1108
|
+
E5,
|
|
1109
|
+
E6,
|
|
1110
|
+
E7,
|
|
1111
|
+
E8
|
|
1112
|
+
]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
|
|
1113
|
+
<Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[
|
|
1114
|
+
E,
|
|
1115
|
+
E2,
|
|
1116
|
+
E3,
|
|
1117
|
+
E4,
|
|
1118
|
+
E5,
|
|
1119
|
+
E6,
|
|
1120
|
+
E7,
|
|
1121
|
+
E8
|
|
1122
|
+
]>>(methods: Ms, path: P, ...handlers: [
|
|
391
1123
|
H<E2, MergedPath, I>,
|
|
392
1124
|
H<E3, MergedPath, I2>,
|
|
393
1125
|
H<E4, MergedPath, I3>,
|
|
@@ -396,8 +1128,28 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = Blan
|
|
|
396
1128
|
H<E7, MergedPath, I6>,
|
|
397
1129
|
H<E8, MergedPath, I7>,
|
|
398
1130
|
H<E9, MergedPath, I8, R>
|
|
399
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
400
|
-
|
|
1131
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
1132
|
+
E,
|
|
1133
|
+
E2,
|
|
1134
|
+
E3,
|
|
1135
|
+
E4,
|
|
1136
|
+
E5,
|
|
1137
|
+
E6,
|
|
1138
|
+
E7,
|
|
1139
|
+
E8,
|
|
1140
|
+
E9
|
|
1141
|
+
]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
|
|
1142
|
+
<Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[
|
|
1143
|
+
E,
|
|
1144
|
+
E2,
|
|
1145
|
+
E3,
|
|
1146
|
+
E4,
|
|
1147
|
+
E5,
|
|
1148
|
+
E6,
|
|
1149
|
+
E7,
|
|
1150
|
+
E8,
|
|
1151
|
+
E9
|
|
1152
|
+
]>>(methods: Ms, path: P, ...handlers: [
|
|
401
1153
|
H<E2, MergedPath, I>,
|
|
402
1154
|
H<E3, MergedPath, I2>,
|
|
403
1155
|
H<E4, MergedPath, I3>,
|
|
@@ -407,8 +1159,30 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = Blan
|
|
|
407
1159
|
H<E8, MergedPath, I7>,
|
|
408
1160
|
H<E9, MergedPath, I8>,
|
|
409
1161
|
H<E10, MergedPath, I9>
|
|
410
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
411
|
-
|
|
1162
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
1163
|
+
E,
|
|
1164
|
+
E2,
|
|
1165
|
+
E3,
|
|
1166
|
+
E4,
|
|
1167
|
+
E5,
|
|
1168
|
+
E6,
|
|
1169
|
+
E7,
|
|
1170
|
+
E8,
|
|
1171
|
+
E9,
|
|
1172
|
+
E10
|
|
1173
|
+
]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I9, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
|
|
1174
|
+
<Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[
|
|
1175
|
+
E,
|
|
1176
|
+
E2,
|
|
1177
|
+
E3,
|
|
1178
|
+
E4,
|
|
1179
|
+
E5,
|
|
1180
|
+
E6,
|
|
1181
|
+
E7,
|
|
1182
|
+
E8,
|
|
1183
|
+
E9,
|
|
1184
|
+
E10
|
|
1185
|
+
]>>(methods: Ms, path: P, ...handlers: [
|
|
412
1186
|
H<E2, MergedPath, I>,
|
|
413
1187
|
H<E3, MergedPath, I2>,
|
|
414
1188
|
H<E4, MergedPath, I3>,
|
|
@@ -419,12 +1193,24 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = Blan
|
|
|
419
1193
|
H<E9, MergedPath, I8>,
|
|
420
1194
|
H<E10, MergedPath, I9>,
|
|
421
1195
|
H<E11, MergedPath, I10>
|
|
422
|
-
]): Hono<IntersectNonAnyTypes<[
|
|
1196
|
+
]): Hono<IntersectNonAnyTypes<[
|
|
1197
|
+
E,
|
|
1198
|
+
E2,
|
|
1199
|
+
E3,
|
|
1200
|
+
E4,
|
|
1201
|
+
E5,
|
|
1202
|
+
E6,
|
|
1203
|
+
E7,
|
|
1204
|
+
E8,
|
|
1205
|
+
E9,
|
|
1206
|
+
E10,
|
|
1207
|
+
E11
|
|
1208
|
+
]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I10, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
|
|
423
1209
|
<P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(methods: string[], path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<string, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
|
|
424
1210
|
<I extends Input = BlankInput, R extends HandlerResponse<any> = any>(methods: string | string[], paths: string[], ...handlers: H<E, any, I, R>[]): Hono<E, S & ToSchema<string, string, I, MergeTypedResponse<R>>, BasePath>;
|
|
425
1211
|
}
|
|
426
1212
|
type ExtractStringKey<S> = keyof S & string;
|
|
427
|
-
export type ToSchema<M extends string, P extends string, I extends Input | Input[
|
|
1213
|
+
export type ToSchema<M extends string, P extends string, I extends Input | Input["in"], RorO> = Simplify<{
|
|
428
1214
|
[K in P]: {
|
|
429
1215
|
[K2 in M as AddDollar<K2>]: Simplify<{
|
|
430
1216
|
input: AddParam<ExtractInput<I>, P>;
|
|
@@ -436,13 +1222,13 @@ export type ToSchema<M extends string, P extends string, I extends Input | Input
|
|
|
436
1222
|
output: unknown extends T ? {} : T;
|
|
437
1223
|
outputFormat: I extends {
|
|
438
1224
|
outputFormat: string;
|
|
439
|
-
} ? I[
|
|
1225
|
+
} ? I["outputFormat"] : F;
|
|
440
1226
|
status: U;
|
|
441
1227
|
} : {
|
|
442
1228
|
output: unknown extends RorO ? {} : RorO;
|
|
443
|
-
outputFormat: unknown extends RorO ?
|
|
1229
|
+
outputFormat: unknown extends RorO ? "json" : I extends {
|
|
444
1230
|
outputFormat: string;
|
|
445
|
-
} ? I[
|
|
1231
|
+
} ? I["outputFormat"] : "json";
|
|
446
1232
|
status: StatusCode;
|
|
447
1233
|
})>;
|
|
448
1234
|
};
|
|
@@ -471,31 +1257,30 @@ type ExtractParams<Path extends string> = string extends Path ? Record<string, s
|
|
|
471
1257
|
type FlattenIfIntersect<T> = T extends infer O ? {
|
|
472
1258
|
[K in keyof O]: O[K];
|
|
473
1259
|
} : never;
|
|
474
|
-
export type MergeSchemaPath<OrigSchema extends Schema, SubPath extends string> =
|
|
475
|
-
[P in keyof OrigSchema as MergePath<SubPath, P & string>]:
|
|
1260
|
+
export type MergeSchemaPath<OrigSchema extends Schema, SubPath extends string> = {
|
|
1261
|
+
[P in keyof OrigSchema as MergePath<SubPath, P & string>]: [
|
|
1262
|
+
OrigSchema[P]
|
|
1263
|
+
] extends [
|
|
1264
|
+
Record<string, Endpoint>
|
|
1265
|
+
] ? {
|
|
476
1266
|
[M in keyof OrigSchema[P]]: MergeEndpointParamsWithPath<OrigSchema[P][M], SubPath>;
|
|
477
|
-
};
|
|
478
|
-
}
|
|
479
|
-
type MergeEndpointParamsWithPath<T, SubPath extends string> = T extends {
|
|
480
|
-
input:
|
|
481
|
-
output: infer Output;
|
|
482
|
-
outputFormat: infer OutputFormat;
|
|
483
|
-
status: infer Status;
|
|
484
|
-
} ? {
|
|
485
|
-
input: Input extends {
|
|
1267
|
+
} : never;
|
|
1268
|
+
};
|
|
1269
|
+
type MergeEndpointParamsWithPath<T extends Endpoint, SubPath extends string> = T extends unknown ? {
|
|
1270
|
+
input: T["input"] extends {
|
|
486
1271
|
param: infer _;
|
|
487
|
-
} ? ExtractParams<SubPath> extends never ?
|
|
1272
|
+
} ? ExtractParams<SubPath> extends never ? T["input"] : FlattenIfIntersect<T["input"] & {
|
|
488
1273
|
param: {
|
|
489
1274
|
[K in keyof ExtractParams<SubPath> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string;
|
|
490
1275
|
};
|
|
491
|
-
}> : RemoveBlankRecord<ExtractParams<SubPath>> extends never ?
|
|
1276
|
+
}> : RemoveBlankRecord<ExtractParams<SubPath>> extends never ? T["input"] : T["input"] & {
|
|
492
1277
|
param: {
|
|
493
1278
|
[K in keyof ExtractParams<SubPath> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string;
|
|
494
1279
|
};
|
|
495
1280
|
};
|
|
496
|
-
output:
|
|
497
|
-
outputFormat:
|
|
498
|
-
status:
|
|
1281
|
+
output: T["output"];
|
|
1282
|
+
outputFormat: T["outputFormat"];
|
|
1283
|
+
status: T["status"];
|
|
499
1284
|
} : never;
|
|
500
1285
|
export type AddParam<I, P extends string> = ParamKeys<P> extends never ? I : I extends {
|
|
501
1286
|
param: infer _;
|
|
@@ -503,10 +1288,10 @@ export type AddParam<I, P extends string> = ParamKeys<P> extends never ? I : I e
|
|
|
503
1288
|
param: UnionToIntersection<ParamKeyToRecord<ParamKeys<P>>>;
|
|
504
1289
|
};
|
|
505
1290
|
type AddDollar<T extends string> = `$${Lowercase<T>}`;
|
|
506
|
-
export type MergePath<A extends string, B extends string> = B extends
|
|
507
|
-
export type KnownResponseFormat =
|
|
1291
|
+
export type MergePath<A extends string, B extends string> = B extends "" ? MergePath<A, "/"> : A extends "" ? B : A extends "/" ? B : A extends `${infer P}/` ? B extends `/${infer Q}` ? `${P}/${Q}` : `${P}/${B}` : B extends `/${infer Q}` ? Q extends "" ? A : `${A}/${Q}` : `${A}/${B}`;
|
|
1292
|
+
export type KnownResponseFormat = "json" | "text" | "redirect";
|
|
508
1293
|
export type ResponseFormat = KnownResponseFormat | string;
|
|
509
|
-
export type TypedResponse<T = unknown, U extends StatusCode = StatusCode, F extends ResponseFormat = T extends string ?
|
|
1294
|
+
export type TypedResponse<T = unknown, U extends StatusCode = StatusCode, F extends ResponseFormat = T extends string ? "text" : T extends JSONValue ? "json" : ResponseFormat> = {
|
|
510
1295
|
_data: T;
|
|
511
1296
|
_status: U;
|
|
512
1297
|
_format: F;
|
|
@@ -528,13 +1313,16 @@ export type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ?
|
|
|
528
1313
|
export type ParamKeyToRecord<T extends string> = T extends `${infer R}?` ? Record<R, string | undefined> : {
|
|
529
1314
|
[K in T]: string;
|
|
530
1315
|
};
|
|
531
|
-
export type InputToDataByTarget<T extends Input[
|
|
1316
|
+
export type InputToDataByTarget<T extends Input["out"], Target extends keyof ValidationTargets> = T extends {
|
|
532
1317
|
[K in Target]: infer R;
|
|
533
1318
|
} ? R : never;
|
|
534
1319
|
export type RemoveQuestion<T> = T extends `${infer R}?` ? R : T;
|
|
535
1320
|
export type ExtractSchema<T> = UnionToIntersection<T extends Hono<infer _, infer S, any> ? S : never>;
|
|
536
1321
|
type EnvOrEmpty<T> = T extends Env ? (Env extends T ? {} : T) : T;
|
|
537
|
-
type IntersectNonAnyTypes<T extends any[]> = T extends [
|
|
1322
|
+
type IntersectNonAnyTypes<T extends any[]> = T extends [
|
|
1323
|
+
infer Head,
|
|
1324
|
+
...infer Rest
|
|
1325
|
+
] ? IfAnyThenEmptyObject<EnvOrEmpty<Head>> & IntersectNonAnyTypes<Rest> : {};
|
|
538
1326
|
export declare abstract class FetchEventLike {
|
|
539
1327
|
abstract readonly request: Request;
|
|
540
1328
|
abstract respondWith(promise: Response | Promise<Response>): void;
|