hono 4.3.7 → 4.3.8

package/dist/cjs/context.js

@@ -155,7 +155,11 @@ class Context {
       const header = new Headers(arg.headers);
       if (this.#headers) {
         this.#headers.forEach((v, k) => {
-          header.set(k, v);
+          if (k === "set-cookie") {
+            header.append(k, v);
+          } else {
+            header.set(k, v);
+          }
         });
       }
       const headers2 = setHeaders(header, this.#preparedHeaders);

package/dist/cjs/utils/jwt/jwt.js

@@ -34,7 +34,11 @@ const encodeJwtPart = (part) => (0, import_encode.encodeBase64Url)(import_utf8.u
 const encodeSignaturePart = (buf) => (0, import_encode.encodeBase64Url)(buf).replace(/=/g, "");
 const decodeJwtPart = (part) => JSON.parse(import_utf8.utf8Decoder.decode((0, import_encode.decodeBase64Url)(part)));
 function isTokenHeader(obj) {
-  return typeof obj === "object" && obj !== null && "alg" in obj && Object.values(import_jwa.AlgorithmTypes).includes(obj.alg) && (!("typ" in obj) || obj.typ === "JWT");
+  if (typeof obj === "object" && obj !== null) {
+    const objWithAlg = obj;
+    return "alg" in objWithAlg && Object.values(import_jwa.AlgorithmTypes).includes(objWithAlg.alg) && (!("typ" in objWithAlg) || objWithAlg.typ === "JWT");
+  }
+  return false;
 }
 const sign = async (payload, privateKey, alg = "HS256") => {
   const encodedPayload = encodeJwtPart(payload);

package/dist/context.js

@@ -132,7 +132,11 @@ var Context = class {
       const header = new Headers(arg.headers);
       if (this.#headers) {
         this.#headers.forEach((v, k) => {
-          header.set(k, v);
+          if (k === "set-cookie") {
+            header.append(k, v);
+          } else {
+            header.set(k, v);
+          }
         });
       }
       const headers2 = setHeaders(header, this.#preparedHeaders);

package/dist/types/context.d.ts

@@ -1,7 +1,7 @@
 import type { HonoRequest } from './request';
 import type { Env, FetchEventLike, Input, NotFoundHandler, TypedResponse } from './types';
 import type { RedirectStatusCode, StatusCode } from './utils/http-status';
-import type { JSONValue, JSONParsed, IsAny, Simplify } from './utils/types';
+import type { IsAny, JSONParsed, JSONValue, Simplify } from './utils/types';
 type HeaderRecord = Record<string, string | string[]>;
 export type Data = string | ArrayBuffer | ReadableStream;
 export interface ExecutionContext {

package/dist/types/jsx/dom/index.d.ts

@@ -31,8 +31,8 @@ declare const _default: {
     useId: () => string;
     useDebugValue: (_value: unknown, _formatter?: ((value: unknown) => string) | undefined) => void;
     createRef: <T_8>() => import("../hooks").RefObject<T_8>;
-    forwardRef: <T_9, P = {}>(Component: (props: P, ref: import("../hooks").RefObject<T_9>) => JSX.Element) => (props: P & {
-        ref: import("../hooks").RefObject<T_9>;
+    forwardRef: <T_9, P = {}>(Component: (props: P, ref?: import("../hooks").RefObject<T_9> | undefined) => JSX.Element) => (props: P & {
+        ref?: import("../hooks").RefObject<T_9> | undefined;
     }) => JSX.Element;
     useImperativeHandle: <T_10>(ref: import("../hooks").RefObject<T_10>, createHandle: () => T_10, deps: readonly unknown[]) => void;
     useSyncExternalStore: <T_11>(subscribe: (callback: (value: T_11) => void) => () => void, getSnapshot: () => T_11, getServerSnapshot?: (() => T_11) | undefined) => T_11;

package/dist/types/jsx/hooks/index.d.ts

@@ -32,8 +32,8 @@ export declare const useMemo: <T>(factory: () => T, deps: readonly unknown[]) =>
 export declare const useId: () => string;
 export declare const useDebugValue: (_value: unknown, _formatter?: ((value: unknown) => string) | undefined) => void;
 export declare const createRef: <T>() => RefObject<T>;
-export declare const forwardRef: <T, P = {}>(Component: (props: P, ref: RefObject<T>) => JSX.Element) => (props: P & {
-    ref: RefObject<T>;
+export declare const forwardRef: <T, P = {}>(Component: (props: P, ref?: RefObject<T> | undefined) => JSX.Element) => (props: P & {
+    ref?: RefObject<T> | undefined;
 }) => JSX.Element;
 export declare const useImperativeHandle: <T>(ref: RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
 export declare const useSyncExternalStore: <T>(subscribe: (callback: (value: T) => void) => () => void, getSnapshot: () => T, getServerSnapshot?: (() => T) | undefined) => T;

package/dist/types/jsx/index.d.ts

@@ -41,8 +41,8 @@ declare const _default: {
     useMemo: <T_11>(factory: () => T_11, deps: readonly unknown[]) => T_11;
     useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
     createRef: <T_12>() => import("./hooks").RefObject<T_12>;
-    forwardRef: <T_13, P = {}>(Component: (props: P, ref: import("./hooks").RefObject<T_13>) => JSX.Element) => (props: P & {
-        ref: import("./hooks").RefObject<T_13>;
+    forwardRef: <T_13, P = {}>(Component: (props: P, ref?: import("./hooks").RefObject<T_13> | undefined) => JSX.Element) => (props: P & {
+        ref?: import("./hooks").RefObject<T_13> | undefined;
     }) => JSX.Element;
     useImperativeHandle: <T_14>(ref: import("./hooks").RefObject<T_14>, createHandle: () => T_14, deps: readonly unknown[]) => void;
     useSyncExternalStore: <T_15>(subscribe: (callback: (value: T_15) => void) => () => void, getSnapshot: () => T_15, getServerSnapshot?: (() => T_15) | undefined) => T_15;

package/dist/types/middleware/jwt/index.d.ts

@@ -11,9 +11,9 @@ export declare const jwt: (options: {
     cookie?: string;
     alg?: SignatureAlgorithm;
 }) => MiddlewareHandler;
-export declare const verify: (token: string, publicKey: import("../../utils/jwt/jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<any>;
+export declare const verify: (token: string, publicKey: import("../../utils/jwt/jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<import("../../utils/jwt/types").JWTPayload>;
 export declare const decode: (token: string) => {
-    header: any;
-    payload: any;
+    header: import("../../utils/jwt/jwt").TokenHeader;
+    payload: import("../../utils/jwt/types").JWTPayload;
 };
 export declare const sign: (payload: import("../../utils/jwt/types").JWTPayload, privateKey: import("../../utils/jwt/jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<string>;

package/dist/types/middleware/secure-headers/index.d.ts

@@ -49,7 +49,7 @@ interface SecureHeadersOptions {
     crossOriginEmbedderPolicy?: overridableHeader;
     crossOriginResourcePolicy?: overridableHeader;
     crossOriginOpenerPolicy?: overridableHeader;
-    originAgentCluster: overridableHeader;
+    originAgentCluster?: overridableHeader;
     referrerPolicy?: overridableHeader;
     reportingEndpoints?: ReportingEndpointOptions[];
     reportTo?: ReportToOptions[];
@@ -62,5 +62,5 @@ interface SecureHeadersOptions {
     xXssProtection?: overridableHeader;
 }
 export declare const NONCE: ContentSecurityPolicyOptionHandler;
-export declare const secureHeaders: (customOptions?: Partial<SecureHeadersOptions>) => MiddlewareHandler;
+export declare const secureHeaders: (customOptions?: SecureHeadersOptions) => MiddlewareHandler;
 export {};

package/dist/types/middleware/timing/index.d.ts

@@ -14,13 +14,13 @@ interface Timer {
     start: number;
 }
 interface TimingOptions {
-    total: boolean;
-    enabled: boolean | ((c: Context) => boolean);
-    totalDescription: string;
-    autoEnd: boolean;
-    crossOrigin: boolean | string | ((c: Context) => boolean | string);
+    total?: boolean;
+    enabled?: boolean | ((c: Context) => boolean);
+    totalDescription?: string;
+    autoEnd?: boolean;
+    crossOrigin?: boolean | string | ((c: Context) => boolean | string);
 }
-export declare const timing: (config?: Partial<TimingOptions>) => MiddlewareHandler;
+export declare const timing: (config?: TimingOptions) => MiddlewareHandler;
 interface SetMetric {
     (c: Context, name: string, value: number, description?: string, precision?: number): void;
     (c: Context, name: string, description?: string): void;

package/dist/types/utils/jwt/index.d.ts

@@ -1,8 +1,8 @@
 export declare const Jwt: {
     sign: (payload: import("./types").JWTPayload, privateKey: import("./jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<string>;
-    verify: (token: string, publicKey: import("./jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<any>;
+    verify: (token: string, publicKey: import("./jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<import("./types").JWTPayload>;
     decode: (token: string) => {
-        header: any;
-        payload: any;
+        header: import("./jwt").TokenHeader;
+        payload: import("./types").JWTPayload;
     };
 };

package/dist/types/utils/jwt/jwt.d.ts

@@ -1,14 +1,14 @@
-import type { SignatureAlgorithm } from './jwa';
-import type { SignatureKey } from './jws';
+import { type SignatureAlgorithm } from './jwa';
+import { type SignatureKey } from './jws';
 import { type JWTPayload } from './types';
 export interface TokenHeader {
     alg: SignatureAlgorithm;
     typ?: 'JWT';
 }
-export declare function isTokenHeader(obj: any): obj is TokenHeader;
+export declare function isTokenHeader(obj: unknown): obj is TokenHeader;
 export declare const sign: (payload: JWTPayload, privateKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<string>;
-export declare const verify: (token: string, publicKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<any>;
+export declare const verify: (token: string, publicKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<JWTPayload>;
 export declare const decode: (token: string) => {
-    header: any;
-    payload: any;
+    header: TokenHeader;
+    payload: JWTPayload;
 };

package/dist/types/utils/jwt/types.d.ts

@@ -32,7 +32,7 @@ export declare enum CryptoKeyUsage {
 /**
  * JWT Payload
  */
-export type JWTPayload = (unknown & {}) | {
+export type JWTPayload = {
     [key: string]: unknown;
     /**
      * The token is checked to ensure it has not expired.

package/dist/utils/jwt/jwt.js

@@ -15,7 +15,11 @@ var encodeJwtPart = (part) => encodeBase64Url(utf8Encoder.encode(JSON.stringify(
 var encodeSignaturePart = (buf) => encodeBase64Url(buf).replace(/=/g, "");
 var decodeJwtPart = (part) => JSON.parse(utf8Decoder.decode(decodeBase64Url(part)));
 function isTokenHeader(obj) {
-  return typeof obj === "object" && obj !== null && "alg" in obj && Object.values(AlgorithmTypes).includes(obj.alg) && (!("typ" in obj) || obj.typ === "JWT");
+  if (typeof obj === "object" && obj !== null) {
+    const objWithAlg = obj;
+    return "alg" in objWithAlg && Object.values(AlgorithmTypes).includes(objWithAlg.alg) && (!("typ" in objWithAlg) || objWithAlg.typ === "JWT");
+  }
+  return false;
 }
 var sign = async (payload, privateKey, alg = "HS256") => {
   const encodedPayload = encodeJwtPart(payload);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.3.7",
+  "version": "4.3.8",
   "description": "Ultrafast web framework for the Edges",
   "main": "dist/cjs/index.js",
   "type": "module",