hono-utils 0.5.0 → 0.5.1

package/README.md

@@ -34,13 +34,13 @@ import { QueueHandler } from 'hono-utils';
 ### Crypto
 
 ```ts
-import { pbkdf2, sha } from 'hono-utils';
+import { pbkdf2, sha } from 'hono-utils/crypto';
 ```
 
 ### Client
 
 ```ts
-import { createTypedClient } from 'hono-utils';
+import { createTypedClient } from 'hono-utils/client';
 ```
 
 ### Router
@@ -67,7 +67,6 @@ import { onError, onNotFound } from 'hono-utils';
   - [response](docs/middleware/response.md)
   - [validator](docs/middleware/validator.md)
   - [withLogger](docs/middleware/withLogger.md)
-  - [hydrateVariable](docs/middleware/hydrateVariable.md)
 
 - Queue
   - [QueueHandler](docs/queue/QueueHandler.md)

package/dist/client/createTypedClient.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+const client = require('hono/client');
+const httpException = require('hono/http-exception');
+
+const createTypedClient = () => {
+  return (options) => async (fn, callbacks) => {
+    const client$1 = client.hc(options.url, {
+      headers: options.headers,
+      fetch: options.fetch
+    });
+    callbacks?.onStart?.();
+    let responseHeaders = new Headers();
+    try {
+      const response = await fn(client$1);
+      responseHeaders = response.headers;
+      const data = await client.parseResponse(response);
+      callbacks?.onSuccess?.(data, responseHeaders);
+      return data;
+    } catch (err) {
+      const { detail, statusCode } = err;
+      const status = statusCode ?? 500;
+      if (!detail) {
+        options.errorHandler?.(status, {
+          message: "Fetch malformed"
+        });
+        throw new httpException.HTTPException(status, { message: "Fetch malformed" });
+      }
+      const { message } = detail;
+      const eventId = responseHeaders.get("x-event-id") ?? void 0;
+      options.errorHandler?.(status, { ...detail, eventId, status });
+      callbacks?.onError?.(detail, responseHeaders);
+      throw new httpException.HTTPException(status, { message });
+    } finally {
+      callbacks?.onEnd?.();
+    }
+  };
+};
+
+exports.createTypedClient = createTypedClient;
+//# sourceMappingURL=createTypedClient.cjs.map

package/dist/client/createTypedClient.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTypedClient.cjs","sources":["../../src/client/createTypedClient.ts"],"sourcesContent":["import { hc } from 'hono/client';\nimport { parseResponse } from 'hono/client';\nimport type { ClientResponse } from 'hono/client';\nimport type { Hono } from 'hono';\nimport type { ContentfulStatusCode, StatusCode } from 'hono/utils/http-status';\nimport { HTTPException } from 'hono/http-exception';\n\ntype ErrorBody = Record<string, unknown>;\n\nexport interface TypedClientCallbacks {\n  onStart?: () => void;\n  onSuccess?: (parsedData: unknown, headers: Headers) => void;\n  onError?: (parsedData: unknown, headers: Headers) => void;\n  onEnd?: () => void;\n}\n\nexport interface CreateTypedClientOptions {\n  url: string;\n  headers?:\n    | Record<string, string>\n    | (() => Record<string, string> | Promise<Record<string, string>>);\n  fetch?: typeof fetch;\n  errorHandler?: (status: StatusCode | number, body?: ErrorBody) => never;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const createTypedClient = <TApp extends Hono<any, any, any>>() => {\n  return (options: CreateTypedClientOptions) =>\n    async <TSuccessData>(\n      fn: (\n        c: ReturnType<typeof hc<TApp>>\n      ) => Promise<ClientResponse<TSuccessData>>,\n      callbacks?: TypedClientCallbacks\n    ): Promise<TSuccessData> => {\n      const client = hc<TApp>(options.url, {\n        headers: options.headers,\n        fetch: options.fetch,\n      });\n      callbacks?.onStart?.();\n\n      // We keep a reference to headers to use them in the catch block if needed\n      let responseHeaders: Headers = new Headers();\n\n      try {\n        // 1. Execute the raw request\n        const response = await fn(client);\n        responseHeaders = response.headers;\n\n        // 2. Use Hono's native parseResponse\n        // This automatically:\n        // - Checks response.ok (throws DetailedError if false)\n        // - Parses JSON/Text based on Content-Type\n        const data = await parseResponse(response);\n\n        // 3. Handle Success\n        callbacks?.onSuccess?.(data, responseHeaders);\n        return data as TSuccessData;\n      } catch (err) {\n        // 4. Handle Errors\n        const { detail, statusCode } = err as {\n          detail?: TSuccessData;\n          statusCode?: ContentfulStatusCode;\n        };\n\n        const status = statusCode ?? 500;\n\n        if (!detail) {\n          options.errorHandler?.(status, {\n            message: 'Fetch malformed',\n          });\n          throw new HTTPException(status, { message: 'Fetch malformed' });\n        }\n\n        const { message } = detail as unknown as {\n          message: string;\n        };\n\n        const eventId = responseHeaders.get('x-event-id') ?? undefined;\n\n        options.errorHandler?.(status, { ...detail, eventId, status });\n        callbacks?.onError?.(detail, responseHeaders);\n\n        throw new HTTPException(status, { message });\n      } finally {\n        callbacks?.onEnd?.();\n      }\n    };\n};\n"],"names":["client","hc","parseResponse","HTTPException"],"mappings":";;;;;AA0BO,MAAM,oBAAoB,MAAwC;AACvE,EAAA,OAAO,CAAC,OAAA,KACN,OACE,EAAA,EAGA,SAAA,KAC0B;AAC1B,IAAA,MAAMA,QAAA,GAASC,SAAA,CAAS,OAAA,CAAQ,GAAA,EAAK;AAAA,MACnC,SAAS,OAAA,CAAQ,OAAA;AAAA,MACjB,OAAO,OAAA,CAAQ;AAAA,KAChB,CAAA;AACD,IAAA,SAAA,EAAW,OAAA,IAAU;AAGrB,IAAA,IAAI,eAAA,GAA2B,IAAI,OAAA,EAAQ;AAE3C,IAAA,IAAI;AAEF,MAAA,MAAM,QAAA,GAAW,MAAM,EAAA,CAAGD,QAAM,CAAA;AAChC,MAAA,eAAA,GAAkB,QAAA,CAAS,OAAA;AAM3B,MAAA,MAAM,IAAA,GAAO,MAAME,oBAAA,CAAc,QAAQ,CAAA;AAGzC,MAAA,SAAA,EAAW,SAAA,GAAY,MAAM,eAAe,CAAA;AAC5C,MAAA,OAAO,IAAA;AAAA,IACT,SAAS,GAAA,EAAK;AAEZ,MAAA,MAAM,EAAE,MAAA,EAAQ,UAAA,EAAW,GAAI,GAAA;AAK/B,MAAA,MAAM,SAAS,UAAA,IAAc,GAAA;AAE7B,MAAA,IAAI,CAAC,MAAA,EAAQ;AACX,QAAA,OAAA,CAAQ,eAAe,MAAA,EAAQ;AAAA,UAC7B,OAAA,EAAS;AAAA,SACV,CAAA;AACD,QAAA,MAAM,IAAIC,2BAAA,CAAc,MAAA,EAAQ,EAAE,OAAA,EAAS,mBAAmB,CAAA;AAAA,MAChE;AAEA,MAAA,MAAM,EAAE,SAAQ,GAAI,MAAA;AAIpB,MAAA,MAAM,OAAA,GAAU,eAAA,CAAgB,GAAA,CAAI,YAAY,CAAA,IAAK,MAAA;AAErD,MAAA,OAAA,CAAQ,eAAe,MAAA,EAAQ,EAAE,GAAG,MAAA,EAAQ,OAAA,EAAS,QAAQ,CAAA;AAC7D,MAAA,SAAA,EAAW,OAAA,GAAU,QAAQ,eAAe,CAAA;AAE5C,MAAA,MAAM,IAAIA,2BAAA,CAAc,MAAA,EAAQ,EAAE,SAAS,CAAA;AAAA,IAC7C,CAAA,SAAE;AACA,MAAA,SAAA,EAAW,KAAA,IAAQ;AAAA,IACrB;AAAA,EACF,CAAA;AACJ;;;;"}

package/dist/client/createTypedClient.d.cts

@@ -0,0 +1,21 @@
+import { hc, ClientResponse } from 'hono/client';
+import { Hono } from 'hono';
+import { StatusCode } from 'hono/utils/http-status';
+
+type ErrorBody = Record<string, unknown>;
+interface TypedClientCallbacks {
+    onStart?: () => void;
+    onSuccess?: (parsedData: unknown, headers: Headers) => void;
+    onError?: (parsedData: unknown, headers: Headers) => void;
+    onEnd?: () => void;
+}
+interface CreateTypedClientOptions {
+    url: string;
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    fetch?: typeof fetch;
+    errorHandler?: (status: StatusCode | number, body?: ErrorBody) => never;
+}
+declare const createTypedClient: <TApp extends Hono<any, any, any>>() => (options: CreateTypedClientOptions) => <TSuccessData>(fn: (c: ReturnType<typeof hc<TApp>>) => Promise<ClientResponse<TSuccessData>>, callbacks?: TypedClientCallbacks) => Promise<TSuccessData>;
+
+export { createTypedClient };
+export type { CreateTypedClientOptions, TypedClientCallbacks };

package/dist/client/createTypedClient.d.mts

@@ -0,0 +1,21 @@
+import { hc, ClientResponse } from 'hono/client';
+import { Hono } from 'hono';
+import { StatusCode } from 'hono/utils/http-status';
+
+type ErrorBody = Record<string, unknown>;
+interface TypedClientCallbacks {
+    onStart?: () => void;
+    onSuccess?: (parsedData: unknown, headers: Headers) => void;
+    onError?: (parsedData: unknown, headers: Headers) => void;
+    onEnd?: () => void;
+}
+interface CreateTypedClientOptions {
+    url: string;
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    fetch?: typeof fetch;
+    errorHandler?: (status: StatusCode | number, body?: ErrorBody) => never;
+}
+declare const createTypedClient: <TApp extends Hono<any, any, any>>() => (options: CreateTypedClientOptions) => <TSuccessData>(fn: (c: ReturnType<typeof hc<TApp>>) => Promise<ClientResponse<TSuccessData>>, callbacks?: TypedClientCallbacks) => Promise<TSuccessData>;
+
+export { createTypedClient };
+export type { CreateTypedClientOptions, TypedClientCallbacks };

package/dist/client/createTypedClient.d.ts

@@ -0,0 +1,21 @@
+import { hc, ClientResponse } from 'hono/client';
+import { Hono } from 'hono';
+import { StatusCode } from 'hono/utils/http-status';
+
+type ErrorBody = Record<string, unknown>;
+interface TypedClientCallbacks {
+    onStart?: () => void;
+    onSuccess?: (parsedData: unknown, headers: Headers) => void;
+    onError?: (parsedData: unknown, headers: Headers) => void;
+    onEnd?: () => void;
+}
+interface CreateTypedClientOptions {
+    url: string;
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    fetch?: typeof fetch;
+    errorHandler?: (status: StatusCode | number, body?: ErrorBody) => never;
+}
+declare const createTypedClient: <TApp extends Hono<any, any, any>>() => (options: CreateTypedClientOptions) => <TSuccessData>(fn: (c: ReturnType<typeof hc<TApp>>) => Promise<ClientResponse<TSuccessData>>, callbacks?: TypedClientCallbacks) => Promise<TSuccessData>;
+
+export { createTypedClient };
+export type { CreateTypedClientOptions, TypedClientCallbacks };

package/dist/client/createTypedClient.mjs

@@ -0,0 +1,39 @@
+import { hc, parseResponse } from 'hono/client';
+import { HTTPException } from 'hono/http-exception';
+
+const createTypedClient = () => {
+  return (options) => async (fn, callbacks) => {
+    const client = hc(options.url, {
+      headers: options.headers,
+      fetch: options.fetch
+    });
+    callbacks?.onStart?.();
+    let responseHeaders = new Headers();
+    try {
+      const response = await fn(client);
+      responseHeaders = response.headers;
+      const data = await parseResponse(response);
+      callbacks?.onSuccess?.(data, responseHeaders);
+      return data;
+    } catch (err) {
+      const { detail, statusCode } = err;
+      const status = statusCode ?? 500;
+      if (!detail) {
+        options.errorHandler?.(status, {
+          message: "Fetch malformed"
+        });
+        throw new HTTPException(status, { message: "Fetch malformed" });
+      }
+      const { message } = detail;
+      const eventId = responseHeaders.get("x-event-id") ?? void 0;
+      options.errorHandler?.(status, { ...detail, eventId, status });
+      callbacks?.onError?.(detail, responseHeaders);
+      throw new HTTPException(status, { message });
+    } finally {
+      callbacks?.onEnd?.();
+    }
+  };
+};
+
+export { createTypedClient };
+//# sourceMappingURL=createTypedClient.mjs.map

package/dist/client/createTypedClient.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTypedClient.mjs","sources":["../../src/client/createTypedClient.ts"],"sourcesContent":["import { hc } from 'hono/client';\nimport { parseResponse } from 'hono/client';\nimport type { ClientResponse } from 'hono/client';\nimport type { Hono } from 'hono';\nimport type { ContentfulStatusCode, StatusCode } from 'hono/utils/http-status';\nimport { HTTPException } from 'hono/http-exception';\n\ntype ErrorBody = Record<string, unknown>;\n\nexport interface TypedClientCallbacks {\n  onStart?: () => void;\n  onSuccess?: (parsedData: unknown, headers: Headers) => void;\n  onError?: (parsedData: unknown, headers: Headers) => void;\n  onEnd?: () => void;\n}\n\nexport interface CreateTypedClientOptions {\n  url: string;\n  headers?:\n    | Record<string, string>\n    | (() => Record<string, string> | Promise<Record<string, string>>);\n  fetch?: typeof fetch;\n  errorHandler?: (status: StatusCode | number, body?: ErrorBody) => never;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const createTypedClient = <TApp extends Hono<any, any, any>>() => {\n  return (options: CreateTypedClientOptions) =>\n    async <TSuccessData>(\n      fn: (\n        c: ReturnType<typeof hc<TApp>>\n      ) => Promise<ClientResponse<TSuccessData>>,\n      callbacks?: TypedClientCallbacks\n    ): Promise<TSuccessData> => {\n      const client = hc<TApp>(options.url, {\n        headers: options.headers,\n        fetch: options.fetch,\n      });\n      callbacks?.onStart?.();\n\n      // We keep a reference to headers to use them in the catch block if needed\n      let responseHeaders: Headers = new Headers();\n\n      try {\n        // 1. Execute the raw request\n        const response = await fn(client);\n        responseHeaders = response.headers;\n\n        // 2. Use Hono's native parseResponse\n        // This automatically:\n        // - Checks response.ok (throws DetailedError if false)\n        // - Parses JSON/Text based on Content-Type\n        const data = await parseResponse(response);\n\n        // 3. Handle Success\n        callbacks?.onSuccess?.(data, responseHeaders);\n        return data as TSuccessData;\n      } catch (err) {\n        // 4. Handle Errors\n        const { detail, statusCode } = err as {\n          detail?: TSuccessData;\n          statusCode?: ContentfulStatusCode;\n        };\n\n        const status = statusCode ?? 500;\n\n        if (!detail) {\n          options.errorHandler?.(status, {\n            message: 'Fetch malformed',\n          });\n          throw new HTTPException(status, { message: 'Fetch malformed' });\n        }\n\n        const { message } = detail as unknown as {\n          message: string;\n        };\n\n        const eventId = responseHeaders.get('x-event-id') ?? undefined;\n\n        options.errorHandler?.(status, { ...detail, eventId, status });\n        callbacks?.onError?.(detail, responseHeaders);\n\n        throw new HTTPException(status, { message });\n      } finally {\n        callbacks?.onEnd?.();\n      }\n    };\n};\n"],"names":[],"mappings":";;;AA0BO,MAAM,oBAAoB,MAAwC;AACvE,EAAA,OAAO,CAAC,OAAA,KACN,OACE,EAAA,EAGA,SAAA,KAC0B;AAC1B,IAAA,MAAM,MAAA,GAAS,EAAA,CAAS,OAAA,CAAQ,GAAA,EAAK;AAAA,MACnC,SAAS,OAAA,CAAQ,OAAA;AAAA,MACjB,OAAO,OAAA,CAAQ;AAAA,KAChB,CAAA;AACD,IAAA,SAAA,EAAW,OAAA,IAAU;AAGrB,IAAA,IAAI,eAAA,GAA2B,IAAI,OAAA,EAAQ;AAE3C,IAAA,IAAI;AAEF,MAAA,MAAM,QAAA,GAAW,MAAM,EAAA,CAAG,MAAM,CAAA;AAChC,MAAA,eAAA,GAAkB,QAAA,CAAS,OAAA;AAM3B,MAAA,MAAM,IAAA,GAAO,MAAM,aAAA,CAAc,QAAQ,CAAA;AAGzC,MAAA,SAAA,EAAW,SAAA,GAAY,MAAM,eAAe,CAAA;AAC5C,MAAA,OAAO,IAAA;AAAA,IACT,SAAS,GAAA,EAAK;AAEZ,MAAA,MAAM,EAAE,MAAA,EAAQ,UAAA,EAAW,GAAI,GAAA;AAK/B,MAAA,MAAM,SAAS,UAAA,IAAc,GAAA;AAE7B,MAAA,IAAI,CAAC,MAAA,EAAQ;AACX,QAAA,OAAA,CAAQ,eAAe,MAAA,EAAQ;AAAA,UAC7B,OAAA,EAAS;AAAA,SACV,CAAA;AACD,QAAA,MAAM,IAAI,aAAA,CAAc,MAAA,EAAQ,EAAE,OAAA,EAAS,mBAAmB,CAAA;AAAA,MAChE;AAEA,MAAA,MAAM,EAAE,SAAQ,GAAI,MAAA;AAIpB,MAAA,MAAM,OAAA,GAAU,eAAA,CAAgB,GAAA,CAAI,YAAY,CAAA,IAAK,MAAA;AAErD,MAAA,OAAA,CAAQ,eAAe,MAAA,EAAQ,EAAE,GAAG,MAAA,EAAQ,OAAA,EAAS,QAAQ,CAAA;AAC7D,MAAA,SAAA,EAAW,OAAA,GAAU,QAAQ,eAAe,CAAA;AAE5C,MAAA,MAAM,IAAI,aAAA,CAAc,MAAA,EAAQ,EAAE,SAAS,CAAA;AAAA,IAC7C,CAAA,SAAE;AACA,MAAA,SAAA,EAAW,KAAA,IAAQ;AAAA,IACrB;AAAA,EACF,CAAA;AACJ;;;;"}

package/dist/crypto/index.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+const sha = require('../shared/hono-utils.DX3fyaCt.cjs');
+
+async function deriveRawKey(input, salt, iterations) {
+  const encoder = new TextEncoder();
+  const baseKey = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(input),
+    { name: "PBKDF2" },
+    false,
+    ["deriveBits"]
+  );
+  const derivedBits = await crypto.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      salt: salt.buffer,
+      iterations,
+      hash: "SHA-256"
+    },
+    baseKey,
+    256
+  );
+  return new Uint8Array(derivedBits);
+}
+async function hash(input, salt, iterations = 6e5) {
+  const encoder = new TextEncoder();
+  const saltBuffer = encoder.encode(salt);
+  const hashBuffer = await deriveRawKey(input, saltBuffer, iterations);
+  return Array.from(hashBuffer).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function verify(input, salt, storedHash, iterations) {
+  const encoder = new TextEncoder();
+  const saltBuffer = encoder.encode(salt);
+  const generatedBuffer = await deriveRawKey(input, saltBuffer, iterations);
+  const storedBuffer = new Uint8Array(
+    storedHash.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))
+  );
+  if (generatedBuffer.length !== storedBuffer.length) {
+    return false;
+  }
+  let result = 0;
+  for (let i = 0; i < generatedBuffer.length; i++) {
+    result |= generatedBuffer[i] ^ storedBuffer[i];
+  }
+  return result === 0;
+}
+
+const pbkdf2 = {
+  __proto__: null,
+  hash: hash,
+  verify: verify
+};
+
+exports.SHA = sha.sha;
+exports.PBKDF2 = pbkdf2;
+//# sourceMappingURL=index.cjs.map

package/dist/crypto/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../src/crypto/pbkdf2.ts"],"sourcesContent":["/**\n * Internal helper to derive raw cryptographic bits using the PBKDF2 algorithm.\n * * @internal\n * @param {string} input - The plain-text string (password/key) to be hashed.\n * @param {Uint8Array} salt - A cryptographically random salt. Recommended minimum 16 bytes.\n * @param {number} iterations - The number of iterations to perform. (e.g., 600,000).\n * @returns {Promise<Uint8Array>} A promise that resolves to the derived 256-bit key.\n * @throws {Error} If the crypto operation fails or parameters are invalid.\n */\nasync function deriveRawKey(\n  input: string,\n  salt: Uint8Array,\n  iterations: number\n): Promise<Uint8Array> {\n  const encoder = new TextEncoder();\n\n  const baseKey = await crypto.subtle.importKey(\n    'raw',\n    encoder.encode(input),\n    { name: 'PBKDF2' },\n    false,\n    ['deriveBits']\n  );\n\n  const derivedBits = await crypto.subtle.deriveBits(\n    {\n      name: 'PBKDF2',\n      salt: salt.buffer as ArrayBuffer,\n      iterations: iterations,\n      hash: 'SHA-256',\n    },\n    baseKey,\n    256\n  );\n\n  return new Uint8Array(derivedBits);\n}\n\n/**\n * Derives a secure hex-encoded hash from an input string using PBKDF2-HMAC-SHA256.\n * * @example\n * const passwordHash = await hash(\"myPassword123\", \"random-salt-string\");\n * * @param {string} input - The plain-text string to hash.\n * @param {string} salt - The salt string used to randomize the hash.\n * @param {number} [iterations=600000] - The CPU cost factor. Default is 600,000.\n * @returns {Promise<string>} A hex-encoded string representing the derived key.\n */\nexport async function hash(\n  input: string,\n  salt: string,\n  iterations: number = 600000\n): Promise<string> {\n  const encoder = new TextEncoder();\n  const saltBuffer = encoder.encode(salt);\n  const hashBuffer = await deriveRawKey(input, saltBuffer, iterations);\n\n  return Array.from(hashBuffer)\n    .map((b) => b.toString(16).padStart(2, '0'))\n    .join('');\n}\n\n/**\n * Verifies if an input string matches a stored hash using a constant-time comparison.\n * This prevents timing attacks by ensuring the execution time does not reveal\n * how many characters of the hash were correct.\n * * @param {string} input - The plain-text string to verify.\n * @param {string} salt - The salt used during the original hashing.\n * @param {string} storedHash - The hex-encoded hash previously stored in the database.\n * @param {number} iterations - The iteration count used for the original hash.\n * @returns {Promise<boolean>} Resolves to `true` if the input matches the hash, otherwise `false`.\n */\nexport async function verify(\n  input: string,\n  salt: string,\n  storedHash: string,\n  iterations: number\n): Promise<boolean> {\n  const encoder = new TextEncoder();\n  const saltBuffer = encoder.encode(salt);\n\n  // Generate the current hash\n  const generatedBuffer = await deriveRawKey(input, saltBuffer, iterations);\n\n  // Convert stored hex back to buffer for a pure byte-to-byte comparison\n  const storedBuffer = new Uint8Array(\n    storedHash.match(/.{1,2}/g)!.map((byte) => parseInt(byte, 16))\n  );\n\n  // Constant-time comparison on bytes\n  if (generatedBuffer.length !== storedBuffer.length) {\n    return false;\n  }\n\n  let result = 0;\n  for (let i = 0; i < generatedBuffer.length; i++) {\n    result |= generatedBuffer[i] ^ storedBuffer[i];\n  }\n\n  return result === 0;\n}\n"],"names":[],"mappings":";;;;AASA,eAAe,YAAA,CACb,KAAA,EACA,IAAA,EACA,UAAA,EACqB;AACrB,EAAA,MAAM,OAAA,GAAU,IAAI,WAAA,EAAY;AAEhC,EAAA,MAAM,OAAA,GAAU,MAAM,MAAA,CAAO,MAAA,CAAO,SAAA;AAAA,IAClC,KAAA;AAAA,IACA,OAAA,CAAQ,OAAO,KAAK,CAAA;AAAA,IACpB,EAAE,MAAM,QAAA,EAAS;AAAA,IACjB,KAAA;AAAA,IACA,CAAC,YAAY;AAAA,GACf;AAEA,EAAA,MAAM,WAAA,GAAc,MAAM,MAAA,CAAO,MAAA,CAAO,UAAA;AAAA,IACtC;AAAA,MACE,IAAA,EAAM,QAAA;AAAA,MACN,MAAM,IAAA,CAAK,MAAA;AAAA,MACX,UAAA;AAAA,MACA,IAAA,EAAM;AAAA,KACR;AAAA,IACA,OAAA;AAAA,IACA;AAAA,GACF;AAEA,EAAA,OAAO,IAAI,WAAW,WAAW,CAAA;AACnC;AAWA,eAAsB,IAAA,CACpB,KAAA,EACA,IAAA,EACA,UAAA,GAAqB,GAAA,EACJ;AACjB,EAAA,MAAM,OAAA,GAAU,IAAI,WAAA,EAAY;AAChC,EAAA,MAAM,UAAA,GAAa,OAAA,CAAQ,MAAA,CAAO,IAAI,CAAA;AACtC,EAAA,MAAM,UAAA,GAAa,MAAM,YAAA,CAAa,KAAA,EAAO,YAAY,UAAU,CAAA;AAEnE,EAAA,OAAO,MAAM,IAAA,CAAK,UAAU,CAAA,CACzB,GAAA,CAAI,CAAC,CAAA,KAAM,CAAA,CAAE,QAAA,CAAS,EAAE,EAAE,QAAA,CAAS,CAAA,EAAG,GAAG,CAAC,CAAA,CAC1C,KAAK,EAAE,CAAA;AACZ;AAYA,eAAsB,MAAA,CACpB,KAAA,EACA,IAAA,EACA,UAAA,EACA,UAAA,EACkB;AAClB,EAAA,MAAM,OAAA,GAAU,IAAI,WAAA,EAAY;AAChC,EAAA,MAAM,UAAA,GAAa,OAAA,CAAQ,MAAA,CAAO,IAAI,CAAA;AAGtC,EAAA,MAAM,eAAA,GAAkB,MAAM,YAAA,CAAa,KAAA,EAAO,YAAY,UAAU,CAAA;AAGxE,EAAA,MAAM,eAAe,IAAI,UAAA;AAAA,IACvB,UAAA,CAAW,KAAA,CAAM,SAAS,CAAA,CAAG,GAAA,CAAI,CAAC,IAAA,KAAS,QAAA,CAAS,IAAA,EAAM,EAAE,CAAC;AAAA,GAC/D;AAGA,EAAA,IAAI,eAAA,CAAgB,MAAA,KAAW,YAAA,CAAa,MAAA,EAAQ;AAClD,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,IAAI,MAAA,GAAS,CAAA;AACb,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,eAAA,CAAgB,QAAQ,CAAA,EAAA,EAAK;AAC/C,IAAA,MAAA,IAAU,eAAA,CAAgB,CAAC,CAAA,GAAI,YAAA,CAAa,CAAC,CAAA;AAAA,EAC/C;AAEA,EAAA,OAAO,MAAA,KAAW,CAAA;AACpB;;;;;;;;;;;"}

package/dist/crypto/index.d.cts

@@ -0,0 +1,58 @@
+/**
+ * Derives a secure hex-encoded hash from an input string using PBKDF2-HMAC-SHA256.
+ * * @example
+ * const passwordHash = await hash("myPassword123", "random-salt-string");
+ * * @param {string} input - The plain-text string to hash.
+ * @param {string} salt - The salt string used to randomize the hash.
+ * @param {number} [iterations=600000] - The CPU cost factor. Default is 600,000.
+ * @returns {Promise<string>} A hex-encoded string representing the derived key.
+ */
+declare function hash$1(input: string, salt: string, iterations?: number): Promise<string>;
+/**
+ * Verifies if an input string matches a stored hash using a constant-time comparison.
+ * This prevents timing attacks by ensuring the execution time does not reveal
+ * how many characters of the hash were correct.
+ * * @param {string} input - The plain-text string to verify.
+ * @param {string} salt - The salt used during the original hashing.
+ * @param {string} storedHash - The hex-encoded hash previously stored in the database.
+ * @param {number} iterations - The iteration count used for the original hash.
+ * @returns {Promise<boolean>} Resolves to `true` if the input matches the hash, otherwise `false`.
+ */
+declare function verify(input: string, salt: string, storedHash: string, iterations: number): Promise<boolean>;
+
+declare const pbkdf2_verify: typeof verify;
+declare namespace pbkdf2 {
+  export {
+    hash$1 as hash,
+    pbkdf2_verify as verify,
+  };
+}
+
+/**
+ * Generates a cryptographically strong random salt.
+ */
+declare function generateSalt(length?: number): string;
+/**
+ * Calculates the SHA hash of the given input string.
+ * @param algorithm - The algorithm to be used for hashing. Defaults to 256.
+ * @param pepper - An optional string to be prepended to the input before hashing.
+ * @param salt - An optional string to be appended to the input before hashing.
+ * @returns A Promise that resolves to the hashed string.
+ */
+declare function hash({ input, algorithm, pepper, salt, }: {
+    input: string;
+    algorithm: 'SHA-256' | 'SHA-384' | 'SHA-512';
+    pepper?: string;
+    salt?: string;
+}): Promise<string>;
+
+declare const sha_generateSalt: typeof generateSalt;
+declare const sha_hash: typeof hash;
+declare namespace sha {
+  export {
+    sha_generateSalt as generateSalt,
+    sha_hash as hash,
+  };
+}
+
+export { pbkdf2 as PBKDF2, sha as SHA };

package/dist/crypto/index.d.mts

@@ -0,0 +1,58 @@
+/**
+ * Derives a secure hex-encoded hash from an input string using PBKDF2-HMAC-SHA256.
+ * * @example
+ * const passwordHash = await hash("myPassword123", "random-salt-string");
+ * * @param {string} input - The plain-text string to hash.
+ * @param {string} salt - The salt string used to randomize the hash.
+ * @param {number} [iterations=600000] - The CPU cost factor. Default is 600,000.
+ * @returns {Promise<string>} A hex-encoded string representing the derived key.
+ */
+declare function hash$1(input: string, salt: string, iterations?: number): Promise<string>;
+/**
+ * Verifies if an input string matches a stored hash using a constant-time comparison.
+ * This prevents timing attacks by ensuring the execution time does not reveal
+ * how many characters of the hash were correct.
+ * * @param {string} input - The plain-text string to verify.
+ * @param {string} salt - The salt used during the original hashing.
+ * @param {string} storedHash - The hex-encoded hash previously stored in the database.
+ * @param {number} iterations - The iteration count used for the original hash.
+ * @returns {Promise<boolean>} Resolves to `true` if the input matches the hash, otherwise `false`.
+ */
+declare function verify(input: string, salt: string, storedHash: string, iterations: number): Promise<boolean>;
+
+declare const pbkdf2_verify: typeof verify;
+declare namespace pbkdf2 {
+  export {
+    hash$1 as hash,
+    pbkdf2_verify as verify,
+  };
+}
+
+/**
+ * Generates a cryptographically strong random salt.
+ */
+declare function generateSalt(length?: number): string;
+/**
+ * Calculates the SHA hash of the given input string.
+ * @param algorithm - The algorithm to be used for hashing. Defaults to 256.
+ * @param pepper - An optional string to be prepended to the input before hashing.
+ * @param salt - An optional string to be appended to the input before hashing.
+ * @returns A Promise that resolves to the hashed string.
+ */
+declare function hash({ input, algorithm, pepper, salt, }: {
+    input: string;
+    algorithm: 'SHA-256' | 'SHA-384' | 'SHA-512';
+    pepper?: string;
+    salt?: string;
+}): Promise<string>;
+
+declare const sha_generateSalt: typeof generateSalt;
+declare const sha_hash: typeof hash;
+declare namespace sha {
+  export {
+    sha_generateSalt as generateSalt,
+    sha_hash as hash,
+  };
+}
+
+export { pbkdf2 as PBKDF2, sha as SHA };

package/dist/crypto/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Derives a secure hex-encoded hash from an input string using PBKDF2-HMAC-SHA256.
+ * * @example
+ * const passwordHash = await hash("myPassword123", "random-salt-string");
+ * * @param {string} input - The plain-text string to hash.
+ * @param {string} salt - The salt string used to randomize the hash.
+ * @param {number} [iterations=600000] - The CPU cost factor. Default is 600,000.
+ * @returns {Promise<string>} A hex-encoded string representing the derived key.
+ */
+declare function hash$1(input: string, salt: string, iterations?: number): Promise<string>;
+/**
+ * Verifies if an input string matches a stored hash using a constant-time comparison.
+ * This prevents timing attacks by ensuring the execution time does not reveal
+ * how many characters of the hash were correct.
+ * * @param {string} input - The plain-text string to verify.
+ * @param {string} salt - The salt used during the original hashing.
+ * @param {string} storedHash - The hex-encoded hash previously stored in the database.
+ * @param {number} iterations - The iteration count used for the original hash.
+ * @returns {Promise<boolean>} Resolves to `true` if the input matches the hash, otherwise `false`.
+ */
+declare function verify(input: string, salt: string, storedHash: string, iterations: number): Promise<boolean>;
+
+declare const pbkdf2_verify: typeof verify;
+declare namespace pbkdf2 {
+  export {
+    hash$1 as hash,
+    pbkdf2_verify as verify,
+  };
+}
+
+/**
+ * Generates a cryptographically strong random salt.
+ */
+declare function generateSalt(length?: number): string;
+/**
+ * Calculates the SHA hash of the given input string.
+ * @param algorithm - The algorithm to be used for hashing. Defaults to 256.
+ * @param pepper - An optional string to be prepended to the input before hashing.
+ * @param salt - An optional string to be appended to the input before hashing.
+ * @returns A Promise that resolves to the hashed string.
+ */
+declare function hash({ input, algorithm, pepper, salt, }: {
+    input: string;
+    algorithm: 'SHA-256' | 'SHA-384' | 'SHA-512';
+    pepper?: string;
+    salt?: string;
+}): Promise<string>;
+
+declare const sha_generateSalt: typeof generateSalt;
+declare const sha_hash: typeof hash;
+declare namespace sha {
+  export {
+    sha_generateSalt as generateSalt,
+    sha_hash as hash,
+  };
+}
+
+export { pbkdf2 as PBKDF2, sha as SHA };

package/dist/crypto/index.mjs

@@ -0,0 +1,54 @@
+export { s as SHA } from '../shared/hono-utils.BOXr1V_a.mjs';
+
+async function deriveRawKey(input, salt, iterations) {
+  const encoder = new TextEncoder();
+  const baseKey = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(input),
+    { name: "PBKDF2" },
+    false,
+    ["deriveBits"]
+  );
+  const derivedBits = await crypto.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      salt: salt.buffer,
+      iterations,
+      hash: "SHA-256"
+    },
+    baseKey,
+    256
+  );
+  return new Uint8Array(derivedBits);
+}
+async function hash(input, salt, iterations = 6e5) {
+  const encoder = new TextEncoder();
+  const saltBuffer = encoder.encode(salt);
+  const hashBuffer = await deriveRawKey(input, saltBuffer, iterations);
+  return Array.from(hashBuffer).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function verify(input, salt, storedHash, iterations) {
+  const encoder = new TextEncoder();
+  const saltBuffer = encoder.encode(salt);
+  const generatedBuffer = await deriveRawKey(input, saltBuffer, iterations);
+  const storedBuffer = new Uint8Array(
+    storedHash.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))
+  );
+  if (generatedBuffer.length !== storedBuffer.length) {
+    return false;
+  }
+  let result = 0;
+  for (let i = 0; i < generatedBuffer.length; i++) {
+    result |= generatedBuffer[i] ^ storedBuffer[i];
+  }
+  return result === 0;
+}
+
+const pbkdf2 = {
+  __proto__: null,
+  hash: hash,
+  verify: verify
+};
+
+export { pbkdf2 as PBKDF2 };
+//# sourceMappingURL=index.mjs.map

package/dist/crypto/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../src/crypto/pbkdf2.ts"],"sourcesContent":["/**\n * Internal helper to derive raw cryptographic bits using the PBKDF2 algorithm.\n * * @internal\n * @param {string} input - The plain-text string (password/key) to be hashed.\n * @param {Uint8Array} salt - A cryptographically random salt. Recommended minimum 16 bytes.\n * @param {number} iterations - The number of iterations to perform. (e.g., 600,000).\n * @returns {Promise<Uint8Array>} A promise that resolves to the derived 256-bit key.\n * @throws {Error} If the crypto operation fails or parameters are invalid.\n */\nasync function deriveRawKey(\n  input: string,\n  salt: Uint8Array,\n  iterations: number\n): Promise<Uint8Array> {\n  const encoder = new TextEncoder();\n\n  const baseKey = await crypto.subtle.importKey(\n    'raw',\n    encoder.encode(input),\n    { name: 'PBKDF2' },\n    false,\n    ['deriveBits']\n  );\n\n  const derivedBits = await crypto.subtle.deriveBits(\n    {\n      name: 'PBKDF2',\n      salt: salt.buffer as ArrayBuffer,\n      iterations: iterations,\n      hash: 'SHA-256',\n    },\n    baseKey,\n    256\n  );\n\n  return new Uint8Array(derivedBits);\n}\n\n/**\n * Derives a secure hex-encoded hash from an input string using PBKDF2-HMAC-SHA256.\n * * @example\n * const passwordHash = await hash(\"myPassword123\", \"random-salt-string\");\n * * @param {string} input - The plain-text string to hash.\n * @param {string} salt - The salt string used to randomize the hash.\n * @param {number} [iterations=600000] - The CPU cost factor. Default is 600,000.\n * @returns {Promise<string>} A hex-encoded string representing the derived key.\n */\nexport async function hash(\n  input: string,\n  salt: string,\n  iterations: number = 600000\n): Promise<string> {\n  const encoder = new TextEncoder();\n  const saltBuffer = encoder.encode(salt);\n  const hashBuffer = await deriveRawKey(input, saltBuffer, iterations);\n\n  return Array.from(hashBuffer)\n    .map((b) => b.toString(16).padStart(2, '0'))\n    .join('');\n}\n\n/**\n * Verifies if an input string matches a stored hash using a constant-time comparison.\n * This prevents timing attacks by ensuring the execution time does not reveal\n * how many characters of the hash were correct.\n * * @param {string} input - The plain-text string to verify.\n * @param {string} salt - The salt used during the original hashing.\n * @param {string} storedHash - The hex-encoded hash previously stored in the database.\n * @param {number} iterations - The iteration count used for the original hash.\n * @returns {Promise<boolean>} Resolves to `true` if the input matches the hash, otherwise `false`.\n */\nexport async function verify(\n  input: string,\n  salt: string,\n  storedHash: string,\n  iterations: number\n): Promise<boolean> {\n  const encoder = new TextEncoder();\n  const saltBuffer = encoder.encode(salt);\n\n  // Generate the current hash\n  const generatedBuffer = await deriveRawKey(input, saltBuffer, iterations);\n\n  // Convert stored hex back to buffer for a pure byte-to-byte comparison\n  const storedBuffer = new Uint8Array(\n    storedHash.match(/.{1,2}/g)!.map((byte) => parseInt(byte, 16))\n  );\n\n  // Constant-time comparison on bytes\n  if (generatedBuffer.length !== storedBuffer.length) {\n    return false;\n  }\n\n  let result = 0;\n  for (let i = 0; i < generatedBuffer.length; i++) {\n    result |= generatedBuffer[i] ^ storedBuffer[i];\n  }\n\n  return result === 0;\n}\n"],"names":[],"mappings":";;AASA,eAAe,YAAA,CACb,KAAA,EACA,IAAA,EACA,UAAA,EACqB;AACrB,EAAA,MAAM,OAAA,GAAU,IAAI,WAAA,EAAY;AAEhC,EAAA,MAAM,OAAA,GAAU,MAAM,MAAA,CAAO,MAAA,CAAO,SAAA;AAAA,IAClC,KAAA;AAAA,IACA,OAAA,CAAQ,OAAO,KAAK,CAAA;AAAA,IACpB,EAAE,MAAM,QAAA,EAAS;AAAA,IACjB,KAAA;AAAA,IACA,CAAC,YAAY;AAAA,GACf;AAEA,EAAA,MAAM,WAAA,GAAc,MAAM,MAAA,CAAO,MAAA,CAAO,UAAA;AAAA,IACtC;AAAA,MACE,IAAA,EAAM,QAAA;AAAA,MACN,MAAM,IAAA,CAAK,MAAA;AAAA,MACX,UAAA;AAAA,MACA,IAAA,EAAM;AAAA,KACR;AAAA,IACA,OAAA;AAAA,IACA;AAAA,GACF;AAEA,EAAA,OAAO,IAAI,WAAW,WAAW,CAAA;AACnC;AAWA,eAAsB,IAAA,CACpB,KAAA,EACA,IAAA,EACA,UAAA,GAAqB,GAAA,EACJ;AACjB,EAAA,MAAM,OAAA,GAAU,IAAI,WAAA,EAAY;AAChC,EAAA,MAAM,UAAA,GAAa,OAAA,CAAQ,MAAA,CAAO,IAAI,CAAA;AACtC,EAAA,MAAM,UAAA,GAAa,MAAM,YAAA,CAAa,KAAA,EAAO,YAAY,UAAU,CAAA;AAEnE,EAAA,OAAO,MAAM,IAAA,CAAK,UAAU,CAAA,CACzB,GAAA,CAAI,CAAC,CAAA,KAAM,CAAA,CAAE,QAAA,CAAS,EAAE,EAAE,QAAA,CAAS,CAAA,EAAG,GAAG,CAAC,CAAA,CAC1C,KAAK,EAAE,CAAA;AACZ;AAYA,eAAsB,MAAA,CACpB,KAAA,EACA,IAAA,EACA,UAAA,EACA,UAAA,EACkB;AAClB,EAAA,MAAM,OAAA,GAAU,IAAI,WAAA,EAAY;AAChC,EAAA,MAAM,UAAA,GAAa,OAAA,CAAQ,MAAA,CAAO,IAAI,CAAA;AAGtC,EAAA,MAAM,eAAA,GAAkB,MAAM,YAAA,CAAa,KAAA,EAAO,YAAY,UAAU,CAAA;AAGxE,EAAA,MAAM,eAAe,IAAI,UAAA;AAAA,IACvB,UAAA,CAAW,KAAA,CAAM,SAAS,CAAA,CAAG,GAAA,CAAI,CAAC,IAAA,KAAS,QAAA,CAAS,IAAA,EAAM,EAAE,CAAC;AAAA,GAC/D;AAGA,EAAA,IAAI,eAAA,CAAgB,MAAA,KAAW,YAAA,CAAa,MAAA,EAAQ;AAClD,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,IAAI,MAAA,GAAS,CAAA;AACb,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,eAAA,CAAgB,QAAQ,CAAA,EAAA,EAAK;AAC/C,IAAA,MAAA,IAAU,eAAA,CAAgB,CAAC,CAAA,GAAI,YAAA,CAAa,CAAC,CAAA;AAAA,EAC/C;AAEA,EAAA,OAAO,MAAA,KAAW,CAAA;AACpB;;;;;;;;;;"}