@taserjs/router 0.0.0

package/dist/esm/define/handler.js

@@ -0,0 +1,38 @@
+import { pickDefinedSchemas } from "./validators.js";
+import { collectReturnsFromDefinitions } from "@taserjs/router-utils";
+//#region src/define/handler.ts
+function createHandlerBuilder(validators, middlewares, returnsMap) {
+	const builder = {
+		returns(map) {
+			return createHandlerBuilder(validators, middlewares, {
+				...returnsMap,
+				...map
+			});
+		},
+		use(unitOrOptions) {
+			middlewares.push(unitOrOptions);
+			return builder;
+		},
+		handler(fn) {
+			const mergedReturns = {
+				...collectReturnsFromDefinitions(middlewares),
+				...returnsMap
+			};
+			return {
+				$Infer: { Output: void 0 },
+				middlewares: [...middlewares],
+				handler: fn,
+				...pickDefinedSchemas(validators),
+				...Object.keys(mergedReturns).length > 0 ? { returns: mergedReturns } : {}
+			};
+		}
+	};
+	return builder;
+}
+function defineHandler(options) {
+	return createHandlerBuilder(options ?? {}, [], {});
+}
+//#endregion
+export { defineHandler };
+
+//# sourceMappingURL=handler.js.map

package/dist/esm/define/handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.js","names":[],"sources":["../../../src/define/handler.ts"],"sourcesContent":["import type { HandlerBuilder } from '../types/index.js'\nimport type {\n  AppContext,\n  HandlerUnit,\n  MiddlewareDefinition,\n  ReturnsMap,\n  ValidatorParts,\n} from '../types/units.js'\nimport type { Schema } from '../types/schema.js'\nimport { pickDefinedSchemas, type SchemaValidators } from './validators.js'\nimport { collectReturnsFromDefinitions } from '@taserjs/router-utils'\n\nfunction createHandlerBuilder<TAppContext extends Record<string, unknown> = AppContext>(\n  validators: SchemaValidators,\n  middlewares: MiddlewareDefinition[],\n  returnsMap: ReturnsMap,\n): HandlerBuilder<readonly [], ValidatorParts, {}, TAppContext> {\n  const builder = {\n    returns(map: ReturnsMap) {\n      return createHandlerBuilder<TAppContext>(validators, middlewares, { ...returnsMap, ...map })\n    },\n    use(unitOrOptions: MiddlewareDefinition) {\n      middlewares.push(unitOrOptions)\n      return builder\n    },\n    handler(fn: (ctx: unknown) => unknown) {\n      const mwReturns = collectReturnsFromDefinitions(middlewares)\n      const mergedReturns = { ...mwReturns, ...returnsMap }\n      const unit = {\n        $Infer: { Output: undefined as unknown as Response },\n        middlewares: [...middlewares],\n        handler: fn as HandlerUnit<readonly [], ValidatorParts>['handler'],\n        ...pickDefinedSchemas(validators),\n        ...(Object.keys(mergedReturns).length > 0 ? { returns: mergedReturns } : {}),\n      } as HandlerUnit<readonly [], ValidatorParts>\n      return unit\n    },\n  }\n\n  return builder as unknown as HandlerBuilder<readonly [], ValidatorParts, {}, TAppContext>\n}\n\nexport function defineHandler<TAppContext extends Record<string, unknown> = AppContext>(): HandlerBuilder<\n  readonly [],\n  {},\n  {},\n  TAppContext\n>\n\nexport function defineHandler<\n  TAppContext extends Record<string, unknown> = AppContext,\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n>(\n  options: {\n    query?: Schema<TQuery>\n    params?: Schema<TParams>\n    body?: Schema<TBody>\n  },\n): HandlerBuilder<\n  readonly [],\n  { query: TQuery, params: TParams, body: TBody },\n  {},\n  TAppContext\n>\n\nexport function defineHandler<TAppContext extends Record<string, unknown> = AppContext>(\n  options?: SchemaValidators,\n): HandlerBuilder<readonly [], ValidatorParts, {}, TAppContext> {\n  return createHandlerBuilder<TAppContext>(options ?? {}, [], {})\n}\n"],"mappings":";;;AAYA,SAAS,qBACP,YACA,aACA,YAC8D;CAC9D,MAAM,UAAU;EACd,QAAQ,KAAiB;GACvB,OAAO,qBAAkC,YAAY,aAAa;IAAE,GAAG;IAAY,GAAG;GAAI,CAAC;EAC7F;EACA,IAAI,eAAqC;GACvC,YAAY,KAAK,aAAa;GAC9B,OAAO;EACT;EACA,QAAQ,IAA+B;GAErC,MAAM,gBAAgB;IAAE,GADN,8BAA8B,WACrB;IAAW,GAAG;GAAW;GAQpD,OAAO;IANL,QAAQ,EAAE,QAAQ,KAAA,EAAiC;IACnD,aAAa,CAAC,GAAG,WAAW;IAC5B,SAAS;IACT,GAAG,mBAAmB,UAAU;IAChC,GAAI,OAAO,KAAK,aAAa,CAAC,CAAC,SAAS,IAAI,EAAE,SAAS,cAAc,IAAI,CAAC;GAErE;EACT;CACF;CAEA,OAAO;AACT;AA2BA,SAAgB,cACd,SAC8D;CAC9D,OAAO,qBAAkC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAChE"}

package/dist/esm/define/middleware.d.ts

@@ -0,0 +1,85 @@
+import { ReplyResult } from '@taserjs/router-utils';
+import { createTaserCompatHandler } from '@taserjs/router-core';
+import { Awaitable, ReturnsMap } from '../types/index.js';
+import { AppContext, MiddlewareReturnFromParts, MiddlewareUnit, StandaloneMiddlewareContext } from '../types/units.js';
+import { Schema } from '../types/schema.js';
+type HonoMiddlewareHandler = Parameters<typeof createTaserCompatHandler>[0];
+type HonoMiddlewareUnit = MiddlewareUnit<MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+type FluentNext<TState, TCtx> = [TState] extends [undefined] ? [TCtx] extends [undefined] ? () => Promise<ReplyResult> : (args: {
+    ctx: TCtx;
+}) => Promise<ReplyResult> : [TCtx] extends [undefined] ? (args: {
+    state: TState;
+}) => Promise<ReplyResult> : (args: {
+    state: TState;
+    ctx: TCtx;
+}) => Promise<ReplyResult>;
+type FluentMiddlewareBuilder<TQuery = unknown, TParams = unknown, TBody = unknown, TState = undefined, TCtx = undefined, TReturns extends ReturnsMap = {}, TAppContext extends Record<string, unknown> = AppContext> = {
+    returns<const M extends ReturnsMap>(map: M): FluentMiddlewareBuilder<TQuery, TParams, TBody, TState, TCtx, Omit<TReturns, keyof M> & M, TAppContext>;
+    handler(fn: (ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>, next: FluentNext<TState, TCtx>) => Awaitable<ReplyResult | Response | unknown>): MiddlewareUnit<MiddlewareReturnFromParts<TQuery, TParams, TBody, TState extends undefined ? {} : TState, TCtx extends undefined ? {} : TCtx>, TReturns>;
+};
+export declare function defineMiddleware(middleware: HonoMiddlewareHandler): HonoMiddlewareUnit;
+export declare function defineMiddleware<TAppContext extends Record<string, unknown> = AppContext, TState = unknown, TCtx = unknown, TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}>(options: {
+    state: Schema<TState>;
+    ctx: Schema<TCtx>;
+    query?: Schema<TQuery>;
+    params?: Schema<TParams>;
+    body?: Schema<TBody>;
+    returns?: TReturns;
+    handler: (ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>, next: (args: {
+        state: TState;
+        ctx: TCtx;
+    }) => Promise<ReplyResult>) => Awaitable<ReplyResult | Response | unknown>;
+}): MiddlewareUnit<MiddlewareReturnFromParts<TQuery, TParams, TBody, TState, TCtx>, TReturns>;
+export declare function defineMiddleware<TAppContext extends Record<string, unknown> = AppContext, TState = unknown, TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}>(options: {
+    state: Schema<TState>;
+    query?: Schema<TQuery>;
+    params?: Schema<TParams>;
+    body?: Schema<TBody>;
+    returns?: TReturns;
+    handler: (ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>, next: (args: {
+        state: TState;
+    }) => Promise<ReplyResult>) => Awaitable<ReplyResult | Response | unknown>;
+}): MiddlewareUnit<MiddlewareReturnFromParts<TQuery, TParams, TBody, TState>, TReturns>;
+export declare function defineMiddleware<TAppContext extends Record<string, unknown> = AppContext, TCtx = unknown, TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}>(options: {
+    ctx: Schema<TCtx>;
+    query?: Schema<TQuery>;
+    params?: Schema<TParams>;
+    body?: Schema<TBody>;
+    returns?: TReturns;
+    handler: (ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>, next: (args: {
+        ctx: TCtx;
+    }) => Promise<ReplyResult>) => Awaitable<ReplyResult | Response | unknown>;
+}): MiddlewareUnit<MiddlewareReturnFromParts<TQuery, TParams, TBody, {}, TCtx>, TReturns>;
+export declare function defineMiddleware<TAppContext extends Record<string, unknown> = AppContext, TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}>(options: {
+    query?: Schema<TQuery>;
+    params?: Schema<TParams>;
+    body?: Schema<TBody>;
+    returns?: TReturns;
+    handler: (ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>, next: () => Promise<ReplyResult>) => Awaitable<ReplyResult | Response | unknown>;
+}): MiddlewareUnit<MiddlewareReturnFromParts<TQuery, TParams, TBody, {}>, TReturns>;
+export declare function defineMiddleware<TAppContext extends Record<string, unknown> = AppContext>(): FluentMiddlewareBuilder<unknown, unknown, unknown, undefined, undefined, {}, TAppContext>;
+export declare function defineMiddleware<TAppContext extends Record<string, unknown> = AppContext, TQuery = unknown, TParams = unknown, TBody = unknown>(options: {
+    query?: Schema<TQuery>;
+    params?: Schema<TParams>;
+    body?: Schema<TBody>;
+}): FluentMiddlewareBuilder<TQuery, TParams, TBody, undefined, undefined, {}, TAppContext>;
+export declare function defineMiddleware<TAppContext extends Record<string, unknown> = AppContext, TState = unknown, TQuery = unknown, TParams = unknown, TBody = unknown>(options: {
+    state: Schema<TState>;
+    query?: Schema<TQuery>;
+    params?: Schema<TParams>;
+    body?: Schema<TBody>;
+}): FluentMiddlewareBuilder<TQuery, TParams, TBody, TState, undefined, {}, TAppContext>;
+export declare function defineMiddleware<TAppContext extends Record<string, unknown> = AppContext, TCtx = unknown, TQuery = unknown, TParams = unknown, TBody = unknown>(options: {
+    ctx: Schema<TCtx>;
+    query?: Schema<TQuery>;
+    params?: Schema<TParams>;
+    body?: Schema<TBody>;
+}): FluentMiddlewareBuilder<TQuery, TParams, TBody, undefined, TCtx, {}, TAppContext>;
+export declare function defineMiddleware<TAppContext extends Record<string, unknown> = AppContext, TState = unknown, TCtx = unknown, TQuery = unknown, TParams = unknown, TBody = unknown>(options: {
+    state: Schema<TState>;
+    ctx: Schema<TCtx>;
+    query?: Schema<TQuery>;
+    params?: Schema<TParams>;
+    body?: Schema<TBody>;
+}): FluentMiddlewareBuilder<TQuery, TParams, TBody, TState, TCtx, {}, TAppContext>;
+export {};

package/dist/esm/define/middleware.js

@@ -0,0 +1,36 @@
+import { createTaserCompatHandler } from "@taserjs/router-core";
+//#region src/define/middleware.ts
+function createFluentBuilder(state) {
+	return {
+		returns(map) {
+			return createFluentBuilder({
+				...state,
+				returns: {
+					...state.returns ?? {},
+					...map
+				}
+			});
+		},
+		handler(fn) {
+			return {
+				...state,
+				handler: fn,
+				__middlewareAcc: void 0,
+				...state.returns ? { __returns: state.returns } : {}
+			};
+		}
+	};
+}
+function defineMiddleware(options) {
+	if (typeof options === "function") {
+		const honoMiddleware = options;
+		return defineMiddleware({ handler: (ctx, next) => createTaserCompatHandler(honoMiddleware)(ctx, next) });
+	}
+	if (options === void 0) return createFluentBuilder({});
+	if (typeof options === "object" && options !== null && !("handler" in options)) return createFluentBuilder(options);
+	return options;
+}
+//#endregion
+export { defineMiddleware };
+
+//# sourceMappingURL=middleware.js.map

package/dist/esm/define/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.js","names":[],"sources":["../../../src/define/middleware.ts"],"sourcesContent":["import type { ReplyResult } from '@taserjs/router-utils'\nimport { createTaserCompatHandler } from '@taserjs/router-core'\n\nimport type { Awaitable, ReturnsMap } from '../types/index.js'\nimport type {\n  AppContext,\n  MiddlewareReturnFromParts,\n  MiddlewareUnit,\n  StandaloneMiddlewareContext,\n} from '../types/units.js'\nimport type { Schema } from '../types/schema.js'\n\ntype HonoMiddlewareHandler = Parameters<typeof createTaserCompatHandler>[0]\n\ntype HonoMiddlewareUnit = MiddlewareUnit<\n  MiddlewareReturnFromParts<unknown, unknown, unknown, {}>\n>\n\ntype MiddlewareBuilderState<\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n  TState = unknown,\n  TCtx = unknown,\n  TReturns extends ReturnsMap = {},\n> = {\n  state?: Schema<TState>\n  ctx?: Schema<TCtx>\n  query?: Schema<TQuery>\n  params?: Schema<TParams>\n  body?: Schema<TBody>\n  returns?: TReturns\n}\n\ntype FluentNext<TState, TCtx>\n  = [TState] extends [undefined]\n    ? [TCtx] extends [undefined]\n        ? () => Promise<ReplyResult>\n        : (args: { ctx: TCtx }) => Promise<ReplyResult>\n    : [TCtx] extends [undefined]\n        ? (args: { state: TState }) => Promise<ReplyResult>\n        : (args: { state: TState, ctx: TCtx }) => Promise<ReplyResult>\n\ntype FluentMiddlewareBuilder<\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n  TState = undefined,\n  TCtx = undefined,\n  TReturns extends ReturnsMap = {},\n  TAppContext extends Record<string, unknown> = AppContext,\n> = {\n  returns<const M extends ReturnsMap>(\n    map: M,\n  ): FluentMiddlewareBuilder<\n    TQuery,\n    TParams,\n    TBody,\n    TState,\n    TCtx,\n    Omit<TReturns, keyof M> & M,\n    TAppContext\n  >\n  handler(\n    fn: (\n      ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>,\n      next: FluentNext<TState, TCtx>,\n    ) => Awaitable<ReplyResult | Response | unknown>,\n  ): MiddlewareUnit<\n    MiddlewareReturnFromParts<\n      TQuery,\n      TParams,\n      TBody,\n      TState extends undefined ? {} : TState,\n      TCtx extends undefined ? {} : TCtx\n    >,\n    TReturns\n  >\n}\n\nfunction createFluentBuilder<TAppContext extends Record<string, unknown> = AppContext>(\n  state: MiddlewareBuilderState,\n): FluentMiddlewareBuilder<unknown, unknown, unknown, undefined, undefined, {}, TAppContext> {\n  return {\n    returns(map: ReturnsMap) {\n      return createFluentBuilder<TAppContext>({\n        ...state,\n        returns: { ...(state.returns ?? {}), ...map },\n      })\n    },\n    handler(fn: (...args: never[]) => unknown) {\n      const unit = {\n        ...state,\n        handler: fn,\n        __middlewareAcc: undefined as unknown,\n        ...(state.returns ? { __returns: state.returns } : {}),\n      }\n      return unit as unknown as MiddlewareUnit<\n        MiddlewareReturnFromParts<unknown, unknown, unknown, unknown, unknown>,\n        ReturnsMap\n      >\n    },\n  } as unknown as FluentMiddlewareBuilder<unknown, unknown, unknown, undefined, undefined, {}, TAppContext>\n}\n\nexport function defineMiddleware(middleware: HonoMiddlewareHandler): HonoMiddlewareUnit\n\nexport function defineMiddleware<\n  TAppContext extends Record<string, unknown> = AppContext,\n  TState = unknown,\n  TCtx = unknown,\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n  TReturns extends ReturnsMap = {},\n>(\n  options: {\n    state: Schema<TState>\n    ctx: Schema<TCtx>\n    query?: Schema<TQuery>\n    params?: Schema<TParams>\n    body?: Schema<TBody>\n    returns?: TReturns\n    handler: (\n      ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>,\n      next: (args: { state: TState, ctx: TCtx }) => Promise<ReplyResult>,\n    ) => Awaitable<ReplyResult | Response | unknown>\n  },\n): MiddlewareUnit<\n  MiddlewareReturnFromParts<TQuery, TParams, TBody, TState, TCtx>,\n  TReturns\n>\n\nexport function defineMiddleware<\n  TAppContext extends Record<string, unknown> = AppContext,\n  TState = unknown,\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n  TReturns extends ReturnsMap = {},\n>(\n  options: {\n    state: Schema<TState>\n    query?: Schema<TQuery>\n    params?: Schema<TParams>\n    body?: Schema<TBody>\n    returns?: TReturns\n    handler: (\n      ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>,\n      next: (args: { state: TState }) => Promise<ReplyResult>,\n    ) => Awaitable<ReplyResult | Response | unknown>\n  },\n): MiddlewareUnit<\n  MiddlewareReturnFromParts<TQuery, TParams, TBody, TState>,\n  TReturns\n>\n\nexport function defineMiddleware<\n  TAppContext extends Record<string, unknown> = AppContext,\n  TCtx = unknown,\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n  TReturns extends ReturnsMap = {},\n>(\n  options: {\n    ctx: Schema<TCtx>\n    query?: Schema<TQuery>\n    params?: Schema<TParams>\n    body?: Schema<TBody>\n    returns?: TReturns\n    handler: (\n      ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>,\n      next: (args: { ctx: TCtx }) => Promise<ReplyResult>,\n    ) => Awaitable<ReplyResult | Response | unknown>\n  },\n): MiddlewareUnit<\n  MiddlewareReturnFromParts<TQuery, TParams, TBody, {}, TCtx>,\n  TReturns\n>\n\nexport function defineMiddleware<\n  TAppContext extends Record<string, unknown> = AppContext,\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n  TReturns extends ReturnsMap = {},\n>(\n  options: {\n    query?: Schema<TQuery>\n    params?: Schema<TParams>\n    body?: Schema<TBody>\n    returns?: TReturns\n    handler: (\n      ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext>,\n      next: () => Promise<ReplyResult>,\n    ) => Awaitable<ReplyResult | Response | unknown>\n  },\n): MiddlewareUnit<\n  MiddlewareReturnFromParts<TQuery, TParams, TBody, {}>,\n  TReturns\n>\n\nexport function defineMiddleware<\n  TAppContext extends Record<string, unknown> = AppContext,\n>(): FluentMiddlewareBuilder<unknown, unknown, unknown, undefined, undefined, {}, TAppContext>\n\nexport function defineMiddleware<\n  TAppContext extends Record<string, unknown> = AppContext,\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n>(\n  options: {\n    query?: Schema<TQuery>\n    params?: Schema<TParams>\n    body?: Schema<TBody>\n  },\n): FluentMiddlewareBuilder<TQuery, TParams, TBody, undefined, undefined, {}, TAppContext>\n\nexport function defineMiddleware<\n  TAppContext extends Record<string, unknown> = AppContext,\n  TState = unknown,\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n>(\n  options: {\n    state: Schema<TState>\n    query?: Schema<TQuery>\n    params?: Schema<TParams>\n    body?: Schema<TBody>\n  },\n): FluentMiddlewareBuilder<TQuery, TParams, TBody, TState, undefined, {}, TAppContext>\n\nexport function defineMiddleware<\n  TAppContext extends Record<string, unknown> = AppContext,\n  TCtx = unknown,\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n>(\n  options: {\n    ctx: Schema<TCtx>\n    query?: Schema<TQuery>\n    params?: Schema<TParams>\n    body?: Schema<TBody>\n  },\n): FluentMiddlewareBuilder<TQuery, TParams, TBody, undefined, TCtx, {}, TAppContext>\n\nexport function defineMiddleware<\n  TAppContext extends Record<string, unknown> = AppContext,\n  TState = unknown,\n  TCtx = unknown,\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n>(\n  options: {\n    state: Schema<TState>\n    ctx: Schema<TCtx>\n    query?: Schema<TQuery>\n    params?: Schema<TParams>\n    body?: Schema<TBody>\n  },\n): FluentMiddlewareBuilder<TQuery, TParams, TBody, TState, TCtx, {}, TAppContext>\n\nexport function defineMiddleware(options?: unknown): unknown {\n  if (typeof options === 'function') {\n    const honoMiddleware = options as HonoMiddlewareHandler\n    return defineMiddleware({\n      handler: (ctx, next) => createTaserCompatHandler(honoMiddleware)(ctx, next),\n    })\n  }\n\n  if (options === undefined) {\n    return createFluentBuilder({})\n  }\n\n  if (\n    typeof options === 'object'\n    && options !== null\n    && !('handler' in options)\n  ) {\n    return createFluentBuilder(options)\n  }\n\n  return options\n}\n"],"mappings":";;AAgFA,SAAS,oBACP,OAC2F;CAC3F,OAAO;EACL,QAAQ,KAAiB;GACvB,OAAO,oBAAiC;IACtC,GAAG;IACH,SAAS;KAAE,GAAI,MAAM,WAAW,CAAC;KAAI,GAAG;IAAI;GAC9C,CAAC;EACH;EACA,QAAQ,IAAmC;GAOzC,OAAO;IALL,GAAG;IACH,SAAS;IACT,iBAAiB,KAAA;IACjB,GAAI,MAAM,UAAU,EAAE,WAAW,MAAM,QAAQ,IAAI,CAAC;GAE/C;EAIT;CACF;AACF;AAoKA,SAAgB,iBAAiB,SAA4B;CAC3D,IAAI,OAAO,YAAY,YAAY;EACjC,MAAM,iBAAiB;EACvB,OAAO,iBAAiB,EACtB,UAAU,KAAK,SAAS,yBAAyB,cAAc,CAAC,CAAC,KAAK,IAAI,EAC5E,CAAC;CACH;CAEA,IAAI,YAAY,KAAA,GACd,OAAO,oBAAoB,CAAC,CAAC;CAG/B,IACE,OAAO,YAAY,YAChB,YAAY,QACZ,EAAE,aAAa,UAElB,OAAO,oBAAoB,OAAO;CAGpC,OAAO;AACT"}

package/dist/esm/define/validators.d.ts

@@ -0,0 +1,8 @@
+import { Schema } from '../types/schema.js';
+import { SchemaKey } from '../constants.js';
+export type SchemaValidators = {
+    query?: Schema<unknown>;
+    params?: Schema<unknown>;
+    body?: Schema<unknown>;
+};
+export declare function pickDefinedSchemas(source: SchemaValidators, keyMap?: Partial<Record<SchemaKey, string>>): Record<string, Schema<unknown>>;

package/dist/esm/define/validators.js

@@ -0,0 +1,14 @@
+import { SCHEMA_KEYS } from "../constants.js";
+//#region src/define/validators.ts
+function pickDefinedSchemas(source, keyMap) {
+	const result = {};
+	for (const key of SCHEMA_KEYS) {
+		const value = source[key];
+		if (value !== void 0) result[keyMap?.[key] ?? key] = value;
+	}
+	return result;
+}
+//#endregion
+export { pickDefinedSchemas };
+
+//# sourceMappingURL=validators.js.map

package/dist/esm/define/validators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.js","names":[],"sources":["../../../src/define/validators.ts"],"sourcesContent":["import type { Schema } from '../types/schema.js'\nimport { SCHEMA_KEYS, type SchemaKey } from '../constants.js'\n\nexport type SchemaValidators = {\n  query?: Schema<unknown>\n  params?: Schema<unknown>\n  body?: Schema<unknown>\n}\n\nexport function pickDefinedSchemas(\n  source: SchemaValidators,\n  keyMap?: Partial<Record<SchemaKey, string>>,\n): Record<string, Schema<unknown>> {\n  const result: Record<string, Schema<unknown>> = {}\n  for (const key of SCHEMA_KEYS) {\n    const value = source[key]\n    if (value !== undefined) {\n      result[keyMap?.[key] ?? key] = value\n    }\n  }\n  return result\n}\n"],"mappings":";;AASA,SAAgB,mBACd,QACA,QACiC;CACjC,MAAM,SAA0C,CAAC;CACjD,KAAK,MAAM,OAAO,aAAa;EAC7B,MAAM,QAAQ,OAAO;EACrB,IAAI,UAAU,KAAA,GACZ,OAAO,SAAS,QAAQ,OAAO;CAEnC;CACA,OAAO;AACT"}

package/dist/esm/factories.d.ts

@@ -0,0 +1,61 @@
+import { RouteBuilder, RoutePath, Schema } from './types/index.js';
+import { AppContext, HttpMethod } from './types/units.js';
+type WithoutBodyOptions<TQuery, TParams, TQueryIn = unknown, TParamsIn = unknown> = {
+    query?: Schema<TQuery, TQueryIn>;
+    params?: Schema<TParams, TParamsIn>;
+};
+type WithBodyOptions<TQuery, TParams, TBody, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown> = WithoutBodyOptions<TQuery, TParams, TQueryIn, TParamsIn> & {
+    body?: Schema<TBody, TBodyIn>;
+};
+export type CreateWithoutBodyRoute<M extends 'GET' | 'DELETE' | 'OPTIONS' | 'HEAD', TAppContext extends Record<string, unknown> = AppContext> = {
+    <const Path extends RoutePath>(path: Path): RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>;
+    <const Path extends RoutePath, TQuery = unknown, TParams = unknown, TQueryIn = unknown, TParamsIn = unknown>(path: Path, options: WithoutBodyOptions<TQuery, TParams, TQueryIn, TParamsIn>): RouteBuilder<Path, M, readonly [], {
+        query: TQuery;
+        params: TParams;
+        queryIn: TQueryIn;
+        paramsIn: TParamsIn;
+    }, {}, TAppContext>;
+};
+export type CreateWithBodyRoute<M extends 'POST' | 'PUT' | 'PATCH', TAppContext extends Record<string, unknown> = AppContext> = {
+    <const Path extends RoutePath>(path: Path): RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>;
+    <const Path extends RoutePath, TQuery = unknown, TParams = unknown, TBody = unknown, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown>(path: Path, options: WithBodyOptions<TQuery, TParams, TBody, TQueryIn, TParamsIn, TBodyIn>): RouteBuilder<Path, M, readonly [], {
+        query: TQuery;
+        params: TParams;
+        body: TBody;
+        queryIn: TQueryIn;
+        paramsIn: TParamsIn;
+        bodyIn: TBodyIn;
+    }, {}, TAppContext>;
+};
+export type CreateAnyRoute<TAppContext extends Record<string, unknown> = AppContext> = {
+    <const Path extends RoutePath, const Methods extends readonly HttpMethod[]>(path: Path, methods: Methods): RouteBuilder<Path, Methods[number], readonly [], {}, {}, TAppContext>;
+    <const Path extends RoutePath, const Methods extends readonly HttpMethod[], TQuery = unknown, TParams = unknown, TBody = unknown, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown>(path: Path, methods: Methods, options: WithBodyOptions<TQuery, TParams, TBody, TQueryIn, TParamsIn, TBodyIn>): RouteBuilder<Path, Methods[number], readonly [], {
+        query: TQuery;
+        params: TParams;
+        body: TBody;
+        queryIn: TQueryIn;
+        paramsIn: TParamsIn;
+        bodyIn: TBodyIn;
+    }, {}, TAppContext>;
+};
+export type CreateAllRoute<TAppContext extends Record<string, unknown> = AppContext> = {
+    <const Path extends RoutePath>(path: Path): RouteBuilder<Path, HttpMethod, readonly [], {}, {}, TAppContext>;
+    <const Path extends RoutePath, TQuery = unknown, TParams = unknown, TBody = unknown, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown>(path: Path, options: WithBodyOptions<TQuery, TParams, TBody, TQueryIn, TParamsIn, TBodyIn>): RouteBuilder<Path, HttpMethod, readonly [], {
+        query: TQuery;
+        params: TParams;
+        body: TBody;
+        queryIn: TQueryIn;
+        paramsIn: TParamsIn;
+        bodyIn: TBodyIn;
+    }, {}, TAppContext>;
+};
+export declare const createGetRoute: CreateWithoutBodyRoute<"GET", AppContext>;
+export declare const createDeleteRoute: CreateWithoutBodyRoute<"DELETE", AppContext>;
+export declare const createOptionsRoute: CreateWithoutBodyRoute<"OPTIONS", AppContext>;
+export declare const createHeadRoute: CreateWithoutBodyRoute<"HEAD", AppContext>;
+export declare const createPostRoute: CreateWithBodyRoute<"POST", AppContext>;
+export declare const createPutRoute: CreateWithBodyRoute<"PUT", AppContext>;
+export declare const createPatchRoute: CreateWithBodyRoute<"PATCH", AppContext>;
+export declare const createAnyRoute: CreateAnyRoute;
+export declare const createAllRoute: CreateAllRoute;
+export {};

package/dist/esm/factories.js

@@ -0,0 +1,21 @@
+import { createRouteBuilder } from "./route.js";
+//#region src/factories.ts
+function createWithoutBodyRoute(method) {
+	return ((path, options) => createRouteBuilder(path, method, options));
+}
+function createWithBodyRoute(method) {
+	return ((path, options) => createRouteBuilder(path, method, options));
+}
+var createGetRoute = createWithoutBodyRoute("GET");
+var createDeleteRoute = createWithoutBodyRoute("DELETE");
+var createOptionsRoute = createWithoutBodyRoute("OPTIONS");
+var createHeadRoute = createWithoutBodyRoute("HEAD");
+var createPostRoute = createWithBodyRoute("POST");
+var createPutRoute = createWithBodyRoute("PUT");
+var createPatchRoute = createWithBodyRoute("PATCH");
+var createAnyRoute = ((path, methods, options) => createRouteBuilder(path, "ANY", options, methods));
+var createAllRoute = ((path, options) => createRouteBuilder(path, "ALL", options));
+//#endregion
+export { createAllRoute, createAnyRoute, createDeleteRoute, createGetRoute, createHeadRoute, createOptionsRoute, createPatchRoute, createPostRoute, createPutRoute };
+
+//# sourceMappingURL=factories.js.map

package/dist/esm/factories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factories.js","names":[],"sources":["../../src/factories.ts"],"sourcesContent":["import { createRouteBuilder } from './route.js'\nimport type { RouteBuilder, RoutePath, Schema } from './types/index.js'\nimport type { AppContext, HttpMethod } from './types/units.js'\n\ntype WithoutBodyOptions<TQuery, TParams, TQueryIn = unknown, TParamsIn = unknown> = {\n  query?: Schema<TQuery, TQueryIn>\n  params?: Schema<TParams, TParamsIn>\n}\n\ntype WithBodyOptions<\n  TQuery,\n  TParams,\n  TBody,\n  TQueryIn = unknown,\n  TParamsIn = unknown,\n  TBodyIn = unknown,\n> = WithoutBodyOptions<TQuery, TParams, TQueryIn, TParamsIn> & {\n  body?: Schema<TBody, TBodyIn>\n}\n\nexport type CreateWithoutBodyRoute<\n  M extends 'GET' | 'DELETE' | 'OPTIONS' | 'HEAD',\n  TAppContext extends Record<string, unknown> = AppContext,\n> = {\n  <const Path extends RoutePath>(path: Path): RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>\n  <\n    const Path extends RoutePath,\n    TQuery = unknown,\n    TParams = unknown,\n    TQueryIn = unknown,\n    TParamsIn = unknown,\n  >(\n    path: Path,\n    options: WithoutBodyOptions<TQuery, TParams, TQueryIn, TParamsIn>,\n  ): RouteBuilder<\n    Path,\n    M,\n    readonly [],\n    {\n      query: TQuery\n      params: TParams\n      queryIn: TQueryIn\n      paramsIn: TParamsIn\n    },\n    {},\n    TAppContext\n  >\n}\n\nexport type CreateWithBodyRoute<\n  M extends 'POST' | 'PUT' | 'PATCH',\n  TAppContext extends Record<string, unknown> = AppContext,\n> = {\n  <const Path extends RoutePath>(path: Path): RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>\n  <\n    const Path extends RoutePath,\n    TQuery = unknown,\n    TParams = unknown,\n    TBody = unknown,\n    TQueryIn = unknown,\n    TParamsIn = unknown,\n    TBodyIn = unknown,\n  >(\n    path: Path,\n    options: WithBodyOptions<TQuery, TParams, TBody, TQueryIn, TParamsIn, TBodyIn>,\n  ): RouteBuilder<\n    Path,\n    M,\n    readonly [],\n    {\n      query: TQuery\n      params: TParams\n      body: TBody\n      queryIn: TQueryIn\n      paramsIn: TParamsIn\n      bodyIn: TBodyIn\n    },\n    {},\n    TAppContext\n  >\n}\n\nexport type CreateAnyRoute<TAppContext extends Record<string, unknown> = AppContext> = {\n  <const Path extends RoutePath, const Methods extends readonly HttpMethod[]>(\n    path: Path,\n    methods: Methods,\n  ): RouteBuilder<Path, Methods[number], readonly [], {}, {}, TAppContext>\n  <\n    const Path extends RoutePath,\n    const Methods extends readonly HttpMethod[],\n    TQuery = unknown,\n    TParams = unknown,\n    TBody = unknown,\n    TQueryIn = unknown,\n    TParamsIn = unknown,\n    TBodyIn = unknown,\n  >(\n    path: Path,\n    methods: Methods,\n    options: WithBodyOptions<TQuery, TParams, TBody, TQueryIn, TParamsIn, TBodyIn>,\n  ): RouteBuilder<\n    Path,\n    Methods[number],\n    readonly [],\n    {\n      query: TQuery\n      params: TParams\n      body: TBody\n      queryIn: TQueryIn\n      paramsIn: TParamsIn\n      bodyIn: TBodyIn\n    },\n    {},\n    TAppContext\n  >\n}\n\nexport type CreateAllRoute<TAppContext extends Record<string, unknown> = AppContext> = {\n  <const Path extends RoutePath>(path: Path): RouteBuilder<Path, HttpMethod, readonly [], {}, {}, TAppContext>\n  <\n    const Path extends RoutePath,\n    TQuery = unknown,\n    TParams = unknown,\n    TBody = unknown,\n    TQueryIn = unknown,\n    TParamsIn = unknown,\n    TBodyIn = unknown,\n  >(\n    path: Path,\n    options: WithBodyOptions<TQuery, TParams, TBody, TQueryIn, TParamsIn, TBodyIn>,\n  ): RouteBuilder<\n    Path,\n    HttpMethod,\n    readonly [],\n    {\n      query: TQuery\n      params: TParams\n      body: TBody\n      queryIn: TQueryIn\n      paramsIn: TParamsIn\n      bodyIn: TBodyIn\n    },\n    {},\n    TAppContext\n  >\n}\n\nfunction createWithoutBodyRoute<M extends 'GET' | 'DELETE' | 'OPTIONS' | 'HEAD'>(\n  method: M,\n): CreateWithoutBodyRoute<M> {\n  return ((path: string, options?: WithoutBodyOptions<unknown, unknown>) =>\n    createRouteBuilder(path, method, options)\n  ) as unknown as CreateWithoutBodyRoute<M>\n}\n\nfunction createWithBodyRoute<M extends 'POST' | 'PUT' | 'PATCH'>(\n  method: M,\n): CreateWithBodyRoute<M> {\n  return ((path: string, options?: WithBodyOptions<unknown, unknown, unknown>) =>\n    createRouteBuilder(path, method, options)\n  ) as unknown as CreateWithBodyRoute<M>\n}\n\nexport const createGetRoute = createWithoutBodyRoute('GET')\nexport const createDeleteRoute = createWithoutBodyRoute('DELETE')\nexport const createOptionsRoute = createWithoutBodyRoute('OPTIONS')\nexport const createHeadRoute = createWithoutBodyRoute('HEAD')\nexport const createPostRoute = createWithBodyRoute('POST')\nexport const createPutRoute = createWithBodyRoute('PUT')\nexport const createPatchRoute = createWithBodyRoute('PATCH')\n\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\nexport const createAnyRoute: CreateAnyRoute = ((\n  path: string,\n  methods: readonly HttpMethod[],\n  options?: WithBodyOptions<unknown, unknown, unknown>,\n) => createRouteBuilder(path, 'ANY', options, methods)) as unknown as CreateAnyRoute\n\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\nexport const createAllRoute: CreateAllRoute = ((\n  path: string,\n  options?: WithBodyOptions<unknown, unknown, unknown>,\n) => createRouteBuilder(path, 'ALL', options)) as unknown as CreateAllRoute\n"],"mappings":";;AAmJA,SAAS,uBACP,QAC2B;CAC3B,SAAS,MAAc,YACrB,mBAAmB,MAAM,QAAQ,OAAO;AAE5C;AAEA,SAAS,oBACP,QACwB;CACxB,SAAS,MAAc,YACrB,mBAAmB,MAAM,QAAQ,OAAO;AAE5C;AAEA,IAAa,iBAAiB,uBAAuB,KAAK;AAC1D,IAAa,oBAAoB,uBAAuB,QAAQ;AAChE,IAAa,qBAAqB,uBAAuB,SAAS;AAClE,IAAa,kBAAkB,uBAAuB,MAAM;AAC5D,IAAa,kBAAkB,oBAAoB,MAAM;AACzD,IAAa,iBAAiB,oBAAoB,KAAK;AACvD,IAAa,mBAAmB,oBAAoB,OAAO;AAG3D,IAAa,mBACX,MACA,SACA,YACG,mBAAmB,MAAM,OAAO,SAAS,OAAO;AAGrD,IAAa,mBACX,MACA,YACG,mBAAmB,MAAM,OAAO,OAAO"}

package/dist/esm/index.d.ts

@@ -0,0 +1,12 @@
+export type { RouterRegister } from './register.js';
+export type { InferInput, InferOutput, Method, PathParams, ReturnsMap, RoutePath, Schema, Simplify, } from './types/index.js';
+export type { ContextDefinition, CreateContextArgs, CreateTaserAppOptions, InferAppContext, InferAppManifest, OnErrorOptions, RouteManifestShape, TaserHandler, } from './types/app.js';
+export { isReplyResult, reply, ValidationError, validationErrorSchema, } from '@taserjs/router-utils';
+export type { ReplyBodyKind, ReplyOf, ResponseValidationFailureHandler, SuccessReplyData, SuccessStatusCode, } from '@taserjs/router-utils';
+export { createAnyRoute, createAllRoute } from './factories.js';
+export { createTaserApp, TaserRouter } from './taser-router.js';
+export { TaserApp, TaserMountedApp, TaserNativeBound } from './taser-app.js';
+export { createContext } from './create-context.js';
+export { defineHandler } from './define/handler.js';
+export { defineMiddleware } from './define/middleware.js';
+export type { TaserCookieJar, TaserHeaders } from '@taserjs/router-core';

package/dist/esm/index.js

@@ -0,0 +1,8 @@
+import { createAllRoute, createAnyRoute } from "./factories.js";
+import { defineHandler } from "./define/handler.js";
+import { defineMiddleware } from "./define/middleware.js";
+import { TaserApp, TaserMountedApp, TaserNativeBound } from "./taser-app.js";
+import { TaserRouter, createTaserApp } from "./taser-router.js";
+import { createContext } from "./create-context.js";
+import { ValidationError, isReplyResult, reply, validationErrorSchema } from "@taserjs/router-utils";
+export { TaserApp, TaserMountedApp, TaserNativeBound, TaserRouter, ValidationError, createAllRoute, createAnyRoute, createContext, createTaserApp, defineHandler, defineMiddleware, isReplyResult, reply, validationErrorSchema };

package/dist/esm/middleware/auth.d.ts

@@ -0,0 +1,9 @@
+import { MiddlewareHandler } from 'hono';
+import { InferOutput, Schema } from '../types/schema.js';
+import { MiddlewareReturnFromParts, MiddlewareUnit } from '../types/units.js';
+export declare function wrapHonoMiddleware<F extends (...args: never[]) => MiddlewareHandler>(honoFactory: F): (...args: Parameters<F>) => MiddlewareUnit<MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export type JwtPayloadState<TPayload> = {
+    jwtPayload: TPayload;
+};
+export type AuthMiddlewareUnit<TPayload> = MiddlewareUnit<MiddlewareReturnFromParts<unknown, unknown, unknown, JwtPayloadState<TPayload>>>;
+export declare function createAuthMiddleware<TPayload>(payloadSchema: Schema<TPayload>, honoMw: MiddlewareHandler): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>>;

package/dist/esm/middleware/auth.js

@@ -0,0 +1,33 @@
+import { defineMiddleware } from "../define/middleware.js";
+import { ValidationError, validateSchema } from "@taserjs/router-utils";
+import { createTaserCompatHandler } from "@taserjs/router-core";
+//#region src/middleware/auth.ts
+function wrapHonoMiddleware(honoFactory) {
+	return (...args) => defineMiddleware(honoFactory(...args));
+}
+function asJwtPayloadStateSchema(payloadSchema) {
+	return payloadSchema;
+}
+function createAuthMiddleware(payloadSchema, honoMw) {
+	return defineMiddleware({
+		state: asJwtPayloadStateSchema(payloadSchema),
+		handler: (ctx, next) => {
+			return createTaserCompatHandler(honoMw)(ctx, async () => {
+				const payload = ctx.var.jwtPayload;
+				try {
+					return next({ state: { jwtPayload: await validateSchema(payloadSchema, payload) } });
+				} catch (error) {
+					if (error instanceof ValidationError) return ctx.reply.forbidden({
+						error: "Forbidden",
+						issues: error.issues
+					});
+					throw error;
+				}
+			});
+		}
+	});
+}
+//#endregion
+export { createAuthMiddleware, wrapHonoMiddleware };
+
+//# sourceMappingURL=auth.js.map

package/dist/esm/middleware/auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.js","names":[],"sources":["../../../src/middleware/auth.ts"],"sourcesContent":["import { createTaserCompatHandler } from '@taserjs/router-core'\nimport { validateSchema, ValidationError } from '@taserjs/router-utils'\nimport type { MiddlewareHandler } from 'hono'\n\nimport { defineMiddleware } from '../define/middleware.js'\nimport type { InferOutput, Schema } from '../types/schema.js'\nimport type { MiddlewareReturnFromParts, MiddlewareUnit } from '../types/units.js'\n\nexport function wrapHonoMiddleware<F extends (...args: never[]) => MiddlewareHandler>(\n  honoFactory: F,\n): (...args: Parameters<F>) => MiddlewareUnit<MiddlewareReturnFromParts<unknown, unknown, unknown, {}>> {\n  return (...args) => defineMiddleware(honoFactory(...args))\n}\n\nexport type JwtPayloadState<TPayload> = {\n  jwtPayload: TPayload\n}\n\nexport type AuthMiddlewareUnit<TPayload> = MiddlewareUnit<\n  MiddlewareReturnFromParts<unknown, unknown, unknown, JwtPayloadState<TPayload>>\n>\n\nfunction asJwtPayloadStateSchema<TPayload>(\n  payloadSchema: Schema<TPayload>,\n): Schema<JwtPayloadState<InferOutput<Schema<TPayload>>>> {\n  return payloadSchema as unknown as Schema<JwtPayloadState<InferOutput<Schema<TPayload>>>>\n}\n\nexport function createAuthMiddleware<TPayload>(\n  payloadSchema: Schema<TPayload>,\n  honoMw: MiddlewareHandler,\n): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>> {\n  return defineMiddleware({\n    state: asJwtPayloadStateSchema(payloadSchema),\n    handler: (ctx, next) => {\n      return createTaserCompatHandler(honoMw)(ctx, async () => {\n        const payload = (ctx.var as { jwtPayload?: unknown }).jwtPayload\n        try {\n          const validated = await validateSchema(payloadSchema, payload)\n          return next({ state: { jwtPayload: validated } })\n        }\n        catch (error) {\n          if (error instanceof ValidationError) {\n            return ctx.reply.forbidden({ error: 'Forbidden', issues: error.issues })\n          }\n          throw error\n        }\n      })\n    },\n  })\n}\n"],"mappings":";;;;AAQA,SAAgB,mBACd,aACsG;CACtG,QAAQ,GAAG,SAAS,iBAAiB,YAAY,GAAG,IAAI,CAAC;AAC3D;AAUA,SAAS,wBACP,eACwD;CACxD,OAAO;AACT;AAEA,SAAgB,qBACd,eACA,QACmD;CACnD,OAAO,iBAAiB;EACtB,OAAO,wBAAwB,aAAa;EAC5C,UAAU,KAAK,SAAS;GACtB,OAAO,yBAAyB,MAAM,CAAC,CAAC,KAAK,YAAY;IACvD,MAAM,UAAW,IAAI,IAAiC;IACtD,IAAI;KAEF,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,MADX,eAAe,eAAe,OAAO,EAChB,EAAE,CAAC;IAClD,SACO,OAAO;KACZ,IAAI,iBAAiB,iBACnB,OAAO,IAAI,MAAM,UAAU;MAAE,OAAO;MAAa,QAAQ,MAAM;KAAO,CAAC;KAEzE,MAAM;IACR;GACF,CAAC;EACH;CACF,CAAC;AACH"}

package/dist/esm/middleware/body-limit.d.ts

@@ -0,0 +1,3 @@
+import { bodyLimit as honoBodyLimit } from 'hono/body-limit';
+export declare function bodyLimit(...args: Parameters<typeof honoBodyLimit>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export type BodyLimitOptions = Parameters<typeof honoBodyLimit>[0];

package/dist/esm/middleware/body-limit.js

@@ -0,0 +1,11 @@
+import { wrapHonoMiddleware } from "./auth.js";
+import { bodyLimit as bodyLimit$1 } from "hono/body-limit";
+//#region src/middleware/body-limit.ts
+var honoBodyLimitMiddleware = wrapHonoMiddleware(bodyLimit$1);
+function bodyLimit(...args) {
+	return honoBodyLimitMiddleware(...args);
+}
+//#endregion
+export { bodyLimit };
+
+//# sourceMappingURL=body-limit.js.map

package/dist/esm/middleware/body-limit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"body-limit.js","names":[],"sources":["../../../src/middleware/body-limit.ts"],"sourcesContent":["import { bodyLimit as honoBodyLimit } from 'hono/body-limit'\n\nimport { wrapHonoMiddleware } from './auth.js'\n\nconst honoBodyLimitMiddleware = wrapHonoMiddleware(honoBodyLimit)\n\nexport function bodyLimit(...args: Parameters<typeof honoBodyLimit>) {\n  return honoBodyLimitMiddleware(...args)\n}\n\nexport type BodyLimitOptions = Parameters<typeof honoBodyLimit>[0]\n"],"mappings":";;;AAIA,IAAM,0BAA0B,mBAAmB,WAAa;AAEhE,SAAgB,UAAU,GAAG,MAAwC;CACnE,OAAO,wBAAwB,GAAG,IAAI;AACxC"}

package/dist/esm/middleware/compress.d.ts

@@ -0,0 +1,3 @@
+import { compress as honoCompress } from 'hono/compress';
+export declare function compress(...args: Parameters<typeof honoCompress>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export type CompressOptions = NonNullable<Parameters<typeof honoCompress>[0]>;

package/dist/esm/middleware/compress.js

@@ -0,0 +1,11 @@
+import { wrapHonoMiddleware } from "./auth.js";
+import { compress as compress$1 } from "hono/compress";
+//#region src/middleware/compress.ts
+var honoCompressMiddleware = wrapHonoMiddleware(compress$1);
+function compress(...args) {
+	return honoCompressMiddleware(...args);
+}
+//#endregion
+export { compress };
+
+//# sourceMappingURL=compress.js.map

package/dist/esm/middleware/compress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress.js","names":[],"sources":["../../../src/middleware/compress.ts"],"sourcesContent":["import { compress as honoCompress } from 'hono/compress'\n\nimport { wrapHonoMiddleware } from './auth.js'\n\nconst honoCompressMiddleware = wrapHonoMiddleware(honoCompress)\n\nexport function compress(...args: Parameters<typeof honoCompress>) {\n  return honoCompressMiddleware(...args)\n}\n\nexport type CompressOptions = NonNullable<Parameters<typeof honoCompress>[0]>\n"],"mappings":";;;AAIA,IAAM,yBAAyB,mBAAmB,UAAY;AAE9D,SAAgB,SAAS,GAAG,MAAuC;CACjE,OAAO,uBAAuB,GAAG,IAAI;AACvC"}

package/dist/esm/middleware/cors.d.ts

@@ -0,0 +1,3 @@
+import { cors as honoCors } from 'hono/cors';
+export declare function cors(...args: Parameters<typeof honoCors>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export type CorsOptions = NonNullable<Parameters<typeof honoCors>[0]>;

package/dist/esm/middleware/cors.js

@@ -0,0 +1,11 @@
+import { wrapHonoMiddleware } from "./auth.js";
+import { cors as cors$1 } from "hono/cors";
+//#region src/middleware/cors.ts
+var honoCorsMiddleware = wrapHonoMiddleware(cors$1);
+function cors(...args) {
+	return honoCorsMiddleware(...args);
+}
+//#endregion
+export { cors };
+
+//# sourceMappingURL=cors.js.map

package/dist/esm/middleware/cors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cors.js","names":[],"sources":["../../../src/middleware/cors.ts"],"sourcesContent":["import { cors as honoCors } from 'hono/cors'\n\nimport { wrapHonoMiddleware } from './auth.js'\n\nconst honoCorsMiddleware = wrapHonoMiddleware(honoCors)\n\nexport function cors(...args: Parameters<typeof honoCors>) {\n  return honoCorsMiddleware(...args)\n}\n\nexport type CorsOptions = NonNullable<Parameters<typeof honoCors>[0]>\n"],"mappings":";;;AAIA,IAAM,qBAAqB,mBAAmB,MAAQ;AAEtD,SAAgB,KAAK,GAAG,MAAmC;CACzD,OAAO,mBAAmB,GAAG,IAAI;AACnC"}

package/dist/esm/middleware/csrf.d.ts

@@ -0,0 +1,3 @@
+import { csrf as honoCsrf } from 'hono/csrf';
+export declare function csrf(...args: Parameters<typeof honoCsrf>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export type CsrfOptions = NonNullable<Parameters<typeof honoCsrf>[0]>;

package/dist/esm/middleware/csrf.js

@@ -0,0 +1,11 @@
+import { wrapHonoMiddleware } from "./auth.js";
+import { csrf as csrf$1 } from "hono/csrf";
+//#region src/middleware/csrf.ts
+var honoCsrfMiddleware = wrapHonoMiddleware(csrf$1);
+function csrf(...args) {
+	return honoCsrfMiddleware(...args);
+}
+//#endregion
+export { csrf };
+
+//# sourceMappingURL=csrf.js.map

package/dist/esm/middleware/csrf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"csrf.js","names":[],"sources":["../../../src/middleware/csrf.ts"],"sourcesContent":["import { csrf as honoCsrf } from 'hono/csrf'\n\nimport { wrapHonoMiddleware } from './auth.js'\n\nconst honoCsrfMiddleware = wrapHonoMiddleware(honoCsrf)\n\nexport function csrf(...args: Parameters<typeof honoCsrf>) {\n  return honoCsrfMiddleware(...args)\n}\n\nexport type CsrfOptions = NonNullable<Parameters<typeof honoCsrf>[0]>\n"],"mappings":";;;AAIA,IAAM,qBAAqB,mBAAmB,MAAQ;AAEtD,SAAgB,KAAK,GAAG,MAAmC;CACzD,OAAO,mBAAmB,GAAG,IAAI;AACnC"}

package/dist/esm/middleware/etag.d.ts

@@ -0,0 +1,3 @@
+import { etag as honoEtag } from 'hono/etag';
+export declare function etag(...args: Parameters<typeof honoEtag>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export type EtagOptions = NonNullable<Parameters<typeof honoEtag>[0]>;

package/dist/esm/middleware/etag.js

@@ -0,0 +1,11 @@
+import { wrapHonoMiddleware } from "./auth.js";
+import { etag as etag$1 } from "hono/etag";
+//#region src/middleware/etag.ts
+var honoEtagMiddleware = wrapHonoMiddleware(etag$1);
+function etag(...args) {
+	return honoEtagMiddleware(...args);
+}
+//#endregion
+export { etag };
+
+//# sourceMappingURL=etag.js.map

package/dist/esm/middleware/etag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"etag.js","names":[],"sources":["../../../src/middleware/etag.ts"],"sourcesContent":["import { etag as honoEtag } from 'hono/etag'\n\nimport { wrapHonoMiddleware } from './auth.js'\n\nconst honoEtagMiddleware = wrapHonoMiddleware(honoEtag)\n\nexport function etag(...args: Parameters<typeof honoEtag>) {\n  return honoEtagMiddleware(...args)\n}\n\nexport type EtagOptions = NonNullable<Parameters<typeof honoEtag>[0]>\n"],"mappings":";;;AAIA,IAAM,qBAAqB,mBAAmB,MAAQ;AAEtD,SAAgB,KAAK,GAAG,MAAmC;CACzD,OAAO,mBAAmB,GAAG,IAAI;AACnC"}

package/dist/esm/middleware/jwk.d.ts

@@ -0,0 +1,15 @@
+import { jwk as honoJwk } from 'hono/jwk';
+import { AuthMiddlewareUnit } from './auth.js';
+import { InferOutput, Schema } from '../types/schema.js';
+export type JwkOptions = Parameters<typeof honoJwk>[0];
+export type JwkRequestInit = Pick<RequestInit, 'headers'>;
+export type JwkMiddlewareOptions = JwkOptions & {
+    /** Allow `http://` JWKS URLs (local dev). Default false — requires `https://`. */
+    allowInsecure?: boolean;
+};
+/**
+ * JWK auth middleware. Invalid or missing tokens return **401** (Hono).
+ * Valid tokens whose payload fails `payloadSchema` return **403**.
+ * Static `jwks_uri` must use HTTPS unless `allowInsecure: true`.
+ */
+export declare function jwk<TPayload>(payloadSchema: Schema<TPayload>, options: JwkMiddlewareOptions, init?: JwkRequestInit): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>>;

package/dist/esm/middleware/jwk.js

@@ -0,0 +1,24 @@
+import { createAuthMiddleware } from "./auth.js";
+import { jwk as jwk$1 } from "hono/jwk";
+//#region src/middleware/jwk.ts
+function assertJwksScheme(jwksUri, allowInsecure) {
+	const scheme = new URL(jwksUri).protocol.replace(":", "");
+	if (scheme === "https") return;
+	if (scheme === "http" && allowInsecure) return;
+	throw new Error(`JWKS URL must use https:// (or http:// with allowInsecure: true): "${jwksUri}"`);
+}
+/**
+* JWK auth middleware. Invalid or missing tokens return **401** (Hono).
+* Valid tokens whose payload fails `payloadSchema` return **403**.
+* Static `jwks_uri` must use HTTPS unless `allowInsecure: true`.
+*/
+function jwk(payloadSchema, options, init) {
+	const jwksUri = options.jwks_uri;
+	if (typeof jwksUri === "string") assertJwksScheme(jwksUri, options.allowInsecure ?? false);
+	const { allowInsecure: _allowInsecure, ...honoOptions } = options;
+	return createAuthMiddleware(payloadSchema, jwk$1(honoOptions, init?.headers !== void 0 ? { headers: init.headers } : void 0));
+}
+//#endregion
+export { jwk };
+
+//# sourceMappingURL=jwk.js.map

package/dist/esm/middleware/jwk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwk.js","names":[],"sources":["../../../src/middleware/jwk.ts"],"sourcesContent":["import { jwk as honoJwk } from 'hono/jwk'\n\nimport { createAuthMiddleware, type AuthMiddlewareUnit } from './auth.js'\nimport type { InferOutput, Schema } from '../types/schema.js'\n\nexport type JwkOptions = Parameters<typeof honoJwk>[0]\n\nexport type JwkRequestInit = Pick<RequestInit, 'headers'>\n\nexport type JwkMiddlewareOptions = JwkOptions & {\n  /** Allow `http://` JWKS URLs (local dev). Default false — requires `https://`. */\n  allowInsecure?: boolean\n}\n\nfunction assertJwksScheme(jwksUri: string, allowInsecure: boolean): void {\n  const scheme = new URL(jwksUri).protocol.replace(':', '')\n  if (scheme === 'https') {\n    return\n  }\n  if (scheme === 'http' && allowInsecure) {\n    return\n  }\n  throw new Error(\n    `JWKS URL must use https:// (or http:// with allowInsecure: true): \"${jwksUri}\"`,\n  )\n}\n\n/**\n * JWK auth middleware. Invalid or missing tokens return **401** (Hono).\n * Valid tokens whose payload fails `payloadSchema` return **403**.\n * Static `jwks_uri` must use HTTPS unless `allowInsecure: true`.\n */\nexport function jwk<TPayload>(\n  payloadSchema: Schema<TPayload>,\n  options: JwkMiddlewareOptions,\n  init?: JwkRequestInit,\n): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>> {\n  const jwksUri = options.jwks_uri\n  if (typeof jwksUri === 'string') {\n    assertJwksScheme(jwksUri, options.allowInsecure ?? false)\n  }\n\n  const { allowInsecure: _allowInsecure, ...honoOptions } = options\n  const safeInit = init?.headers !== undefined ? { headers: init.headers } : undefined\n\n  return createAuthMiddleware(payloadSchema, honoJwk(honoOptions, safeInit))\n}\n"],"mappings":";;;AAcA,SAAS,iBAAiB,SAAiB,eAA8B;CACvE,MAAM,SAAS,IAAI,IAAI,OAAO,CAAC,CAAC,SAAS,QAAQ,KAAK,EAAE;CACxD,IAAI,WAAW,SACb;CAEF,IAAI,WAAW,UAAU,eACvB;CAEF,MAAM,IAAI,MACR,sEAAsE,QAAQ,EAChF;AACF;;;;;;AAOA,SAAgB,IACd,eACA,SACA,MACmD;CACnD,MAAM,UAAU,QAAQ;CACxB,IAAI,OAAO,YAAY,UACrB,iBAAiB,SAAS,QAAQ,iBAAiB,KAAK;CAG1D,MAAM,EAAE,eAAe,gBAAgB,GAAG,gBAAgB;CAG1D,OAAO,qBAAqB,eAAe,MAAQ,aAFlC,MAAM,YAAY,KAAA,IAAY,EAAE,SAAS,KAAK,QAAQ,IAAI,KAAA,CAEH,CAAC;AAC3E"}

package/dist/esm/middleware/jwt.d.ts

@@ -0,0 +1,10 @@
+import { jwt as honoJwt } from 'hono/jwt';
+import { AuthMiddlewareUnit } from './auth.js';
+import { InferOutput, Schema } from '../types/schema.js';
+export type JwtOptions = Parameters<typeof honoJwt>[0];
+/**
+ * JWT auth middleware. Invalid or missing tokens return **401** (Hono).
+ * Valid tokens whose payload fails `payloadSchema` return **403**.
+ * Use optional schema fields for intentionally optional claims.
+ */
+export declare function jwt<TPayload>(payloadSchema: Schema<TPayload>, options: JwtOptions): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>>;

package/dist/esm/middleware/jwt.js

@@ -0,0 +1,15 @@
+import { createAuthMiddleware } from "./auth.js";
+import { jwt as jwt$1 } from "hono/jwt";
+//#region src/middleware/jwt.ts
+/**
+* JWT auth middleware. Invalid or missing tokens return **401** (Hono).
+* Valid tokens whose payload fails `payloadSchema` return **403**.
+* Use optional schema fields for intentionally optional claims.
+*/
+function jwt(payloadSchema, options) {
+	return createAuthMiddleware(payloadSchema, jwt$1(options));
+}
+//#endregion
+export { jwt };
+
+//# sourceMappingURL=jwt.js.map

package/dist/esm/middleware/jwt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwt.js","names":[],"sources":["../../../src/middleware/jwt.ts"],"sourcesContent":["import { jwt as honoJwt } from 'hono/jwt'\n\nimport { createAuthMiddleware, type AuthMiddlewareUnit } from './auth.js'\nimport type { InferOutput, Schema } from '../types/schema.js'\n\nexport type JwtOptions = Parameters<typeof honoJwt>[0]\n\n/**\n * JWT auth middleware. Invalid or missing tokens return **401** (Hono).\n * Valid tokens whose payload fails `payloadSchema` return **403**.\n * Use optional schema fields for intentionally optional claims.\n */\nexport function jwt<TPayload>(\n  payloadSchema: Schema<TPayload>,\n  options: JwtOptions,\n): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>> {\n  return createAuthMiddleware(payloadSchema, honoJwt(options))\n}\n"],"mappings":";;;;;;;;AAYA,SAAgB,IACd,eACA,SACmD;CACnD,OAAO,qBAAqB,eAAe,MAAQ,OAAO,CAAC;AAC7D"}

package/dist/esm/middleware/secure-headers.d.ts

@@ -0,0 +1,3 @@
+import { secureHeaders as honoSecureHeaders } from 'hono/secure-headers';
+export declare function secureHeaders(...args: Parameters<typeof honoSecureHeaders>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>;

package/dist/esm/middleware/secure-headers.js

@@ -0,0 +1,11 @@
+import { wrapHonoMiddleware } from "./auth.js";
+import { secureHeaders as secureHeaders$1 } from "hono/secure-headers";
+//#region src/middleware/secure-headers.ts
+var honoSecureHeadersMiddleware = wrapHonoMiddleware(secureHeaders$1);
+function secureHeaders(...args) {
+	return honoSecureHeadersMiddleware(...args);
+}
+//#endregion
+export { secureHeaders };
+
+//# sourceMappingURL=secure-headers.js.map