@sebastienrousseau/crypto-react 0.0.8

package/LICENSE

@@ -0,0 +1,8 @@
+This project is dual-licensed under either of:
+
+  * Apache License, Version 2.0 — see LICENSE-APACHE
+  * MIT license — see LICENSE-MIT
+
+at your option.
+
+SPDX-License-Identifier: Apache-2.0 OR MIT

package/README.md

@@ -0,0 +1,377 @@
+<!-- SPDX-License-Identifier: Apache-2.0 OR MIT -->
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/sebastienrousseau/crypto-service/main/assets/crypto-react-logo.svg" alt="crypto-react logo" width="360" />
+</p>
+
+<h1 align="center">@sebastienrousseau/crypto-react</h1>
+
+<p align="center">
+  React hooks and context provider for client-side cryptographic operations with zero boilerplate.
+</p>
+
+<p align="center">
+  <a href="https://github.com/sebastienrousseau/crypto-service/actions"><img src="https://img.shields.io/github/actions/workflow/status/sebastienrousseau/crypto-service/ci.yml?branch=main&style=for-the-badge&logo=github" alt="Build" /></a>
+  <a href="https://coveralls.io/github/sebastienrousseau/crypto-service?branch=main"><img src="https://img.shields.io/coveralls/github/sebastienrousseau/crypto-service?branch=main&style=for-the-badge" alt="Coverage" /></a>
+  <a href="https://www.npmjs.com/package/@sebastienrousseau/crypto-react"><img src="https://img.shields.io/npm/v/@sebastienrousseau/crypto-react.svg?style=for-the-badge&color=f14041&logo=npm" alt="Registry" /></a>
+  <a href="https://sebastienrousseau.github.io/crypto-service/"><img src="https://img.shields.io/badge/docs-TypeDoc-blue.svg?style=for-the-badge&labelColor=555555&logo=typescript" alt="Docs" /></a>
+  <a href="https://scorecard.dev/viewer/?uri=github.com/sebastienrousseau/crypto-service" title="ossf-scorecard"><img src="https://img.shields.io/badge/OpenSSF-Scorecard-blue?style=for-the-badge&logo=openssf" alt="OpenSSF Scorecard" /></a>
+  <a href="https://github.com/sebastienrousseau/crypto-service/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-Apache--2.0%20OR%20MIT-blue.svg?style=for-the-badge" alt="License: Apache-2.0 OR MIT" /></a>
+  <a href="https://github.com/sebastienrousseau/crypto-service/blob/main/docs/POLICIES.md"><img src="https://img.shields.io/badge/Node.js-%3E%3D22-93450a.svg?style=for-the-badge&logo=node.js" alt="Node.js 22 or newer" /></a>
+  <a href="https://react.dev/"><img src="https://img.shields.io/badge/react-%3E%3D18-61dafb.svg?style=for-the-badge&logo=react" alt="React >= 18" /></a>
+</p>
+
+---
+
+## Contents
+
+**Getting started**
+
+- [Install](#install) — installation via pnpm, npm, or yarn
+- [Requirements](#requirements) — runtime floor and environment prerequisites
+- [Quick Start](#quick-start) — minimal working usage sample
+
+**The Crypto Service ecosystem**
+
+- [The Crypto Service ecosystem](#the-crypto-service-ecosystem) — full 14-package suite overview
+
+**Package reference**
+
+- [Reference & Usage](#overview) — features, configuration, and capabilities
+- [Examples](#examples) — runnable sample code
+
+**Operational**
+
+- [Development](#development) — build, lint, format, and test targets
+- [Security](#security) — vulnerability disclosure and cryptographic invariants
+- [Documentation](#documentation) — TypeDoc API docs and ecosystem guides
+- [Stability guarantees](#stability-guarantees) — SemVer axis and release policy
+- [License](#license)
+
+---
+
+## Install
+
+```bash
+pnpm add @sebastienrousseau/crypto-react
+# or
+npm install @sebastienrousseau/crypto-react
+# or
+yarn add @sebastienrousseau/crypto-react
+```
+
+<p align="right"><a href="#contents">Back to Top</a></p>
+
+---
+
+## Requirements
+
+- **Node.js**: `^22.0.0` or `>=24.0.0` (active and maintenance LTS releases)
+- **Package Manager**: `pnpm >=9` (recommended) or `npm >=10`
+- **TypeScript**: `>=5.0` (when compiling with TypeScript)
+
+<p align="right"><a href="#contents">Back to Top</a></p>
+
+---
+
+## Quick Start
+
+```tsx
+import {
+  CryptoProvider,
+  useKeypair,
+  useEncrypt,
+  useHash,
+  useSignature,
+} from "@sebastienrousseau/crypto-react";
+
+function App() {
+  return (
+    <CryptoProvider defaultKey="deadbeef...64-hex-chars">
+      <MyComponent />
+    </CryptoProvider>
+  );
+}
+
+function MyComponent() {
+  const { generate, publicKey } = useKeypair("ed25519");
+  const { encrypt, decrypt } = useEncrypt();
+  const { hash, digest } = useHash("sha3-256");
+  const { sign, verify } = useSignature();
+
+  return (
+    <div>
+      <button onClick={() => generate()}>Generate Ed25519 Key Pair</button>
+      {publicKey && <code>{publicKey}</code>}
+    </div>
+  );
+}
+```
+
+<p align="right"><a href="#contents">Back to Top</a></p>
+
+---
+
+## The Crypto Service ecosystem
+
+Crypto Service provides a complete cryptography stack across 14 specialized packages:
+
+| Package                                                                   | Role            | Description                                                                                                                            |
+| :------------------------------------------------------------------------ | :-------------- | :------------------------------------------------------------------------------------------------------------------------------------- |
+| [`@sebastienrousseau/crypto-api`](../crypto-api)                          | API Schemas     | Shared TypeScript types and utilities for the Crypto Service Suite, defining the canonical API surface.                                |
+| [`@sebastienrousseau/crypto-cli`](../crypto-cli)                          | Terminal CLI    | An interactive command-line interface for cryptographic operations, supporting both legacy OpenPGP and modern post-quantum algorithms. |
+| [`@sebastienrousseau/crypto-edge`](../crypto-edge)                        | Edge Runtime    | Edge-runtime cryptographic operations using the Web Crypto API, optimized for Cloudflare Workers, Vercel Edge, and Deno.               |
+| [`@sebastienrousseau/crypto-kms`](../crypto-kms)                          | Cloud KMS       | Unified Key Management Service interface for AWS KMS, GCP Cloud KMS, Azure Key Vault, and HashiCorp Vault.                             |
+| [`@sebastienrousseau/crypto-lib`](../crypto-lib)                          | Core Library    | A modern cryptographic library for TypeScript, with post-quantum support, zero unsafe dependencies, and 100% test coverage.            |
+| [`@sebastienrousseau/crypto-middleware`](../crypto-middleware)            | Middleware      | Framework-agnostic cryptographic middleware for Express, Fastify, and Koa applications.                                                |
+| [`@sebastienrousseau/crypto-prisma`](../crypto-prisma)                    | ORM Adapter     | Transparent field-level encryption extension for Prisma Client, using XChaCha20-Poly1305.                                              |
+| **[`@sebastienrousseau/crypto-react`](../crypto-react)** _(this package)_ | **React Hooks** | **React hooks and context provider for client-side cryptographic operations with zero boilerplate.**                                   |
+| [`@sebastienrousseau/crypto-sdk`](../crypto-sdk)                          | Client SDK      | A zero-dependency, typed HTTP client for the Crypto Service REST API, with full post-quantum support.                                  |
+| [`@sebastienrousseau/crypto-server`](../crypto-server)                    | HTTP API        | A hardened Fastify REST API for cryptographic operations, with rate limiting, OpenAPI schemas, and post-quantum endpoints.             |
+| [`@sebastienrousseau/crypto-testing`](../crypto-testing)                  | Test Support    | Deterministic keys, fast mocks, and test fixtures for crypto-lib                                                                       |
+| [`@sebastienrousseau/crypto-typeorm`](../crypto-typeorm)                  | ORM Adapter     | TypeORM column-level encryption with a single decorator, powered by crypto-lib.                                                        |
+| [`@sebastienrousseau/crypto-vue`](../crypto-vue)                          | Vue Composables | Vue 3 composables for client-side cryptography                                                                                         |
+| [`@sebastienrousseau/crypto-wasm`](../crypto-wasm)                        | Acceleration    | WebAssembly performance accelerator for crypto-lib                                                                                     |
+
+<p align="right"><a href="#contents">Back to Top</a></p>
+
+---
+
+## Overview
+
+crypto-react provides React hooks for client-side cryptographic
+operations. It wraps `@sebastienrousseau/crypto-lib` in a reactive
+API with hooks for key generation, symmetric encryption, hashing,
+and digital signatures. A `CryptoProvider` component supplies shared
+configuration (default key, server URL, API key) to all hooks via
+React context.
+
+<p align="right"><a href="#contents">Back to Top</a></p>
+
+## CryptoProvider
+
+Wrap your component tree with `<CryptoProvider>` to supply shared
+configuration to all hooks.
+
+```tsx
+<CryptoProvider
+  defaultKey="a1b2c3d4...64-hex-chars"
+  serverUrl="https://crypto.example.com"
+  apiKey="my-api-key"
+>
+  <App />
+</CryptoProvider>
+```
+
+| Prop         | Type        | Description                              |
+| :----------- | :---------- | :--------------------------------------- |
+| `defaultKey` | `string`    | Hex-encoded 256-bit key for `useEncrypt` |
+| `serverUrl`  | `string`    | Server URL for SDK-backed operations     |
+| `apiKey`     | `string`    | API key for server authentication        |
+| `children`   | `ReactNode` | Child components                         |
+
+Access the context from any child via `useCryptoContext()`.
+
+<p align="right"><a href="#contents">Back to Top</a></p>
+
+## Hooks Reference
+
+| Hook           | Purpose                              | Returns                                                        |
+| :------------- | :----------------------------------- | :------------------------------------------------------------- |
+| `useKeypair`   | Key pair generation (all algorithms) | `{ publicKey, privateKey, algorithm, generate, isGenerating }` |
+| `useEncrypt`   | Symmetric encryption (secretbox)     | `{ encrypt, decrypt, ciphertext, plaintext, isProcessing }`    |
+| `useHash`      | Cryptographic hashing                | `{ hash, digest, isHashing }`                                  |
+| `useSignature` | Digital signatures (sign + verify)   | `{ sign, verify, signature, isValid, isProcessing }`           |
+
+<p align="right"><a href="#contents">Back to Top</a></p>
+
+## Usage
+
+<details>
+<summary><b>Generate a key pair</b></summary>
+
+```tsx
+import { useKeypair } from "@sebastienrousseau/crypto-react";
+
+function KeygenPage() {
+  const { publicKey, generate, isGenerating } = useKeypair("ed25519");
+
+  return (
+    <div>
+      <button onClick={() => generate()} disabled={isGenerating}>
+        Generate Ed25519
+      </button>
+      {publicKey && <code>{publicKey.slice(0, 64)}...</code>}
+    </div>
+  );
+}
+```
+
+</details>
+
+<details>
+<summary><b>Encrypt and decrypt</b></summary>
+
+```tsx
+import { useEncrypt } from "@sebastienrousseau/crypto-react";
+
+function EncryptPage() {
+  const { encrypt, decrypt, ciphertext, plaintext, isProcessing } =
+    useEncrypt();
+
+  return (
+    <div>
+      <button onClick={() => encrypt("secret message")} disabled={isProcessing}>
+        Encrypt
+      </button>
+      {ciphertext && (
+        <button onClick={() => decrypt(ciphertext)} disabled={isProcessing}>
+          Decrypt
+        </button>
+      )}
+      {plaintext && <p>Decrypted: {plaintext}</p>}
+    </div>
+  );
+}
+```
+
+</details>
+
+<details>
+<summary><b>Hash data</b></summary>
+
+```tsx
+import { useHash } from "@sebastienrousseau/crypto-react";
+
+function HashPage() {
+  const { hash, digest, isHashing } = useHash("sha3-256");
+
+  return (
+    <div>
+      <button onClick={() => hash("Hello")} disabled={isHashing}>
+        SHA3-256
+      </button>
+      {digest && <code>{digest}</code>}
+    </div>
+  );
+}
+```
+
+</details>
+
+<details>
+<summary><b>Sign and verify</b></summary>
+
+```tsx
+import { useKeypair, useSignature } from "@sebastienrousseau/crypto-react";
+
+function SignPage() {
+  const { publicKey, privateKey, generate } = useKeypair("ed25519");
+  const { sign, verify, signature, isValid, isProcessing } = useSignature();
+
+  return (
+    <div>
+      <button onClick={() => generate()}>Generate Keys</button>
+      {privateKey && (
+        <button
+          onClick={() => sign(privateKey, "my message")}
+          disabled={isProcessing}
+        >
+          Sign
+        </button>
+      )}
+      {signature && publicKey && (
+        <button
+          onClick={() => verify(publicKey, "my message", signature)}
+          disabled={isProcessing}
+        >
+          Verify
+        </button>
+      )}
+      {isValid !== null && <p>Valid: {isValid ? "Yes" : "No"}</p>}
+    </div>
+  );
+}
+```
+
+</details>
+
+<p align="right"><a href="#contents">Back to Top</a></p>
+
+## Examples
+
+All examples are self-contained TypeScript files in the `examples/`
+directory. Run any example with:
+
+```bash
+npx ts-node examples/<name>.ts
+```
+
+| Category       | Example                             | Purpose                                       |
+| :------------- | :---------------------------------- | :-------------------------------------------- |
+| Provider       | [provider.ts](examples/provider.ts) | CryptoProvider context setup and access       |
+| Key Generation | [keygen.ts](examples/keygen.ts)     | Generate Ed25519 and ML-DSA-65 key pairs      |
+| Encryption     | [encrypt.ts](examples/encrypt.ts)   | Secretbox encrypt and decrypt round-trip      |
+| Hashing        | [hash.ts](examples/hash.ts)         | SHA-256, SHA3-256, and BLAKE3 hashing         |
+| Signing        | [sign.ts](examples/sign.ts)         | Ed25519 sign and verify with tamper detection |
+
+<p align="right"><a href="#contents">Back to Top</a></p>
+
+<p align="right"><a href="#contents">Back to Top</a></p>
+
+---
+
+## Development
+
+```bash
+pnpm --filter @sebastienrousseau/crypto-react run build
+pnpm --filter @sebastienrousseau/crypto-react run test
+pnpm --filter @sebastienrousseau/crypto-react run lint
+pnpm --filter @sebastienrousseau/crypto-react run format
+```
+
+All 18 packages in the Crypto Service workspace maintain a **100% coverage floor** across statements, branches, functions, and lines.
+
+<p align="right"><a href="#contents">Back to Top</a></p>
+
+---
+
+## Security
+
+Report vulnerabilities privately via [GitHub Security Advisories](https://github.com/sebastienrousseau/crypto-service/security/advisories) or according to [`SECURITY.md`](../../SECURITY.md). Never report security issues publicly.
+
+Cryptographic operations use the `@noble/*` libraries, Node.js `crypto` and OpenPGP.js. `@noble/post-quantum` has not been independently audited and does not guarantee constant-time execution, and no module in this suite is FIPS 140-3 validated. Key zeroization is limited: JavaScript strings and garbage-collected buffers cannot be reliably wiped. See [`SECURITY.md`](../../SECURITY.md).
+
+<p align="right"><a href="#contents">Back to Top</a></p>
+
+---
+
+## Documentation
+
+- [Full Suite Documentation](https://sebastienrousseau.github.io/crypto-service/)
+- [API Reference (TypeDoc)](https://sebastienrousseau.github.io/crypto-service/)
+- [Developer Guide](../../DEVELOPMENT.md)
+- [Security Policy](../../SECURITY.md)
+- [Architecture & Design](../../ARCHITECTURE.md)
+
+<p align="right"><a href="#contents">Back to Top</a></p>
+
+---
+
+## Stability guarantees
+
+Versions advance strictly one step at a time on the `0.0.x` line (`v0.0.1` → `v0.0.2` → `v0.0.3` ... → `v0.0.999` → `v0.1.0`). Work for every release iteration begins on a dedicated `feat/v<version>` branch.
+
+All 18 packages in the workspace move in lockstep. Public API signatures, cipher output formats, and serialization schemas are strictly versioned. Breaking changes to serialized formats or algorithm defaults are considered major breaking changes. Minimum toolchain upgrades (e.g. Node.js LTS floor) are governed by [POLICIES.md](../../docs/POLICIES.md).
+
+<p align="right"><a href="#contents">Back to Top</a></p>
+
+---
+
+## License
+
+Dual-licensed under [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0) or [MIT](https://opensource.org/licenses/MIT), at your option.
+
+Copyright (c) 2022-2026 Sebastien Rousseau and The Crypto Service Suite contributors.
+
+<p align="right"><a href="#contents">Back to Top</a></p>

package/dist/hooks/useEncrypt.d.ts

@@ -0,0 +1,9 @@
+export interface UseEncryptResult {
+    encrypt: (plaintext: string | Uint8Array, key?: string) => string;
+    decrypt: (ciphertext: string, key?: string) => string;
+    ciphertext: string | null;
+    plaintext: string | null;
+    isProcessing: boolean;
+}
+export declare function useEncrypt(): UseEncryptResult;
+//# sourceMappingURL=useEncrypt.d.ts.map

package/dist/hooks/useEncrypt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEncrypt.d.ts","sourceRoot":"","sources":["../../src/hooks/useEncrypt.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,gBAAgB;IAE/B,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAElE,OAAO,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAEtD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAEzB,YAAY,EAAE,OAAO,CAAC;CACvB;AAgBD,wBAAgB,UAAU,IAAI,gBAAgB,CAgD7C"}

package/dist/hooks/useEncrypt.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEncrypt = useEncrypt;
+const react_1 = require("react");
+const secretbox_1 = require("@sebastienrousseau/crypto-lib/dist/high-level/secretbox");
+const provider_1 = require("../provider");
+function useEncrypt() {
+    const { defaultKey } = (0, provider_1.useCryptoContext)();
+    const [ciphertext, setCiphertext] = (0, react_1.useState)(null);
+    const [plaintext, setPlaintext] = (0, react_1.useState)(null);
+    const [isProcessing, setIsProcessing] = (0, react_1.useState)(false);
+    const encrypt = (0, react_1.useCallback)((pt, key) => {
+        const k = key ?? defaultKey;
+        if (!k) {
+            throw new Error("No encryption key provided. Pass a key argument or set defaultKey via CryptoProvider.");
+        }
+        setIsProcessing(true);
+        try {
+            const result = (0, secretbox_1.seal)(k, pt);
+            setCiphertext(result.sealed);
+            return result.sealed;
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }, [defaultKey]);
+    const decrypt = (0, react_1.useCallback)((ct, key) => {
+        const k = key ?? defaultKey;
+        if (!k) {
+            throw new Error("No decryption key provided. Pass a key argument or set defaultKey via CryptoProvider.");
+        }
+        setIsProcessing(true);
+        try {
+            const raw = (0, secretbox_1.open)(k, ct);
+            const text = Buffer.from(raw).toString("utf8");
+            setPlaintext(text);
+            return text;
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }, [defaultKey]);
+    return { encrypt, decrypt, ciphertext, plaintext, isProcessing };
+}
+//# sourceMappingURL=useEncrypt.js.map

package/dist/hooks/useHash.d.ts

@@ -0,0 +1,8 @@
+import { type HashAlgorithm } from "@sebastienrousseau/crypto-lib/dist/modern/hash";
+export interface UseHashResult {
+    hash: (data: string | Uint8Array, algorithm?: HashAlgorithm) => string;
+    digest: string | null;
+    isHashing: boolean;
+}
+export declare function useHash(defaultAlgorithm?: HashAlgorithm): UseHashResult;
+//# sourceMappingURL=useHash.d.ts.map

package/dist/hooks/useHash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHash.d.ts","sourceRoot":"","sources":["../../src/hooks/useHash.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,aAAa,EACnB,MAAM,gDAAgD,CAAC;AAUxD,MAAM,WAAW,aAAa;IAE5B,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,SAAS,CAAC,EAAE,aAAa,KAAK,MAAM,CAAC;IAEvE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAEtB,SAAS,EAAE,OAAO,CAAC;CACpB;AAeD,wBAAgB,OAAO,CACrB,gBAAgB,GAAE,aAAwB,GACzC,aAAa,CAsBf"}

package/dist/hooks/useHash.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHash = useHash;
+const react_1 = require("react");
+const hash_1 = require("@sebastienrousseau/crypto-lib/dist/modern/hash");
+function useHash(defaultAlgorithm = "sha256") {
+    const [digest, setDigest] = (0, react_1.useState)(null);
+    const [isHashing, setIsHashing] = (0, react_1.useState)(false);
+    const hash = (0, react_1.useCallback)((data, algorithm) => {
+        setIsHashing(true);
+        try {
+            const result = (0, hash_1.hash)({
+                algorithm: algorithm ?? defaultAlgorithm,
+                data,
+            });
+            setDigest(result.digest);
+            return result.digest;
+        }
+        finally {
+            setIsHashing(false);
+        }
+    }, [defaultAlgorithm]);
+    return { hash, digest, isHashing };
+}
+//# sourceMappingURL=useHash.js.map

package/dist/hooks/useKeypair.d.ts

@@ -0,0 +1,10 @@
+import { type KeyAlgorithm } from "@sebastienrousseau/crypto-lib/dist/keys/keygen";
+export interface UseKeypairResult {
+    publicKey: string | null;
+    privateKey: string | null;
+    algorithm: string | null;
+    generate: (algorithm?: KeyAlgorithm) => void;
+    isGenerating: boolean;
+}
+export declare function useKeypair(defaultAlgorithm?: KeyAlgorithm): UseKeypairResult;
+//# sourceMappingURL=useKeypair.d.ts.map

package/dist/hooks/useKeypair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeypair.d.ts","sourceRoot":"","sources":["../../src/hooks/useKeypair.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,gDAAgD,CAAC;AAUxD,MAAM,WAAW,gBAAgB;IAE/B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAEzB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAEzB,QAAQ,EAAE,CAAC,SAAS,CAAC,EAAE,YAAY,KAAK,IAAI,CAAC;IAE7C,YAAY,EAAE,OAAO,CAAC;CACvB;AAeD,wBAAgB,UAAU,CACxB,gBAAgB,GAAE,YAAwB,GACzC,gBAAgB,CAsBlB"}

package/dist/hooks/useKeypair.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useKeypair = useKeypair;
+const react_1 = require("react");
+const keygen_1 = require("@sebastienrousseau/crypto-lib/dist/keys/keygen");
+function useKeypair(defaultAlgorithm = "ed25519") {
+    const [publicKey, setPublicKey] = (0, react_1.useState)(null);
+    const [privateKey, setPrivateKey] = (0, react_1.useState)(null);
+    const [algorithm, setAlgorithm] = (0, react_1.useState)(null);
+    const [isGenerating, setIsGenerating] = (0, react_1.useState)(false);
+    const generate = (0, react_1.useCallback)((algo = defaultAlgorithm) => {
+        setIsGenerating(true);
+        try {
+            const kp = (0, keygen_1.generateKeyPair)(algo);
+            setPublicKey(kp.publicKey);
+            setPrivateKey(kp.privateKey);
+            setAlgorithm(kp.algorithm);
+        }
+        finally {
+            setIsGenerating(false);
+        }
+    }, [defaultAlgorithm]);
+    return { publicKey, privateKey, algorithm, generate, isGenerating };
+}
+//# sourceMappingURL=useKeypair.js.map

package/dist/hooks/useSignature.d.ts

@@ -0,0 +1,10 @@
+import { type SignAlgorithm } from "@sebastienrousseau/crypto-lib/dist/crypto";
+export interface UseSignatureResult {
+    sign: (privateKey: string, message: string | Uint8Array, algorithm?: SignAlgorithm) => string;
+    verify: (publicKey: string, message: string | Uint8Array, signature: string, algorithm?: SignAlgorithm) => boolean;
+    signature: string | null;
+    isValid: boolean | null;
+    isProcessing: boolean;
+}
+export declare function useSignature(defaultAlgorithm?: SignAlgorithm): UseSignatureResult;
+//# sourceMappingURL=useSignature.d.ts.map

package/dist/hooks/useSignature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSignature.d.ts","sourceRoot":"","sources":["../../src/hooks/useSignature.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,aAAa,EACnB,MAAM,2CAA2C,CAAC;AAUnD,MAAM,WAAW,kBAAkB;IAEjC,IAAI,EAAE,CACJ,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GAAG,UAAU,EAC5B,SAAS,CAAC,EAAE,aAAa,KACtB,MAAM,CAAC;IAEZ,MAAM,EAAE,CACN,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GAAG,UAAU,EAC5B,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,aAAa,KACtB,OAAO,CAAC;IAEb,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAEzB,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAExB,YAAY,EAAE,OAAO,CAAC;CACvB;AAgBD,wBAAgB,YAAY,CAC1B,gBAAgB,GAAE,aAAyB,GAC1C,kBAAkB,CAoDpB"}

package/dist/hooks/useSignature.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSignature = useSignature;
+const react_1 = require("react");
+const crypto_1 = require("@sebastienrousseau/crypto-lib/dist/crypto");
+function useSignature(defaultAlgorithm = "ed25519") {
+    const [signature, setSignature] = (0, react_1.useState)(null);
+    const [isValid, setIsValid] = (0, react_1.useState)(null);
+    const [isProcessing, setIsProcessing] = (0, react_1.useState)(false);
+    const sign = (0, react_1.useCallback)((privateKey, message, algorithm) => {
+        setIsProcessing(true);
+        try {
+            const sig = crypto_1.crypto.sign(algorithm ?? defaultAlgorithm, privateKey, message);
+            setSignature(sig);
+            return sig;
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }, [defaultAlgorithm]);
+    const verify = (0, react_1.useCallback)((publicKey, message, sig, algorithm) => {
+        setIsProcessing(true);
+        try {
+            const valid = crypto_1.crypto.verify(algorithm ?? defaultAlgorithm, publicKey, message, sig);
+            setIsValid(valid);
+            return valid;
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }, [defaultAlgorithm]);
+    return { sign, verify, signature, isValid, isProcessing };
+}
+//# sourceMappingURL=useSignature.js.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { CryptoProvider, useCryptoContext, type CryptoContextValue, type CryptoProviderProps, } from "./provider";
+export { useKeypair, type UseKeypairResult } from "./hooks/useKeypair";
+export { useEncrypt, type UseEncryptResult } from "./hooks/useEncrypt";
+export { useHash, type UseHashResult } from "./hooks/useHash";
+export { useSignature, type UseSignatureResult } from "./hooks/useSignature";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,GACzB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSignature = exports.useHash = exports.useEncrypt = exports.useKeypair = exports.useCryptoContext = exports.CryptoProvider = void 0;
+var provider_1 = require("./provider");
+Object.defineProperty(exports, "CryptoProvider", { enumerable: true, get: function () { return provider_1.CryptoProvider; } });
+Object.defineProperty(exports, "useCryptoContext", { enumerable: true, get: function () { return provider_1.useCryptoContext; } });
+var useKeypair_1 = require("./hooks/useKeypair");
+Object.defineProperty(exports, "useKeypair", { enumerable: true, get: function () { return useKeypair_1.useKeypair; } });
+var useEncrypt_1 = require("./hooks/useEncrypt");
+Object.defineProperty(exports, "useEncrypt", { enumerable: true, get: function () { return useEncrypt_1.useEncrypt; } });
+var useHash_1 = require("./hooks/useHash");
+Object.defineProperty(exports, "useHash", { enumerable: true, get: function () { return useHash_1.useHash; } });
+var useSignature_1 = require("./hooks/useSignature");
+Object.defineProperty(exports, "useSignature", { enumerable: true, get: function () { return useSignature_1.useSignature; } });
+//# sourceMappingURL=index.js.map

package/dist/provider.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from "react";
+export interface CryptoContextValue {
+    defaultKey?: string;
+    serverUrl?: string;
+    apiKey?: string;
+}
+export interface CryptoProviderProps extends CryptoContextValue {
+    children: ReactNode;
+}
+export declare function CryptoProvider({ children, ...config }: CryptoProviderProps): import("react").JSX.Element;
+export declare function useCryptoContext(): CryptoContextValue;
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAsC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAU3E,MAAM,WAAW,kBAAkB;IAEjC,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAYD,MAAM,WAAW,mBAAoB,SAAQ,kBAAkB;IAE7D,QAAQ,EAAE,SAAS,CAAC;CACrB;AAgBD,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,GAAG,MAAM,EAAE,EAAE,mBAAmB,+BAM1E;AAaD,wBAAgB,gBAAgB,IAAI,kBAAkB,CAErD"}

package/dist/provider.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoProvider = CryptoProvider;
+exports.useCryptoContext = useCryptoContext;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const CryptoContext = (0, react_1.createContext)({});
+function CryptoProvider({ children, ...config }) {
+    const value = (0, react_1.useMemo)(() => config, [config.defaultKey, config.serverUrl, config.apiKey]);
+    return (0, jsx_runtime_1.jsx)(CryptoContext.Provider, { value: value, children: children });
+}
+function useCryptoContext() {
+    return (0, react_1.useContext)(CryptoContext);
+}
+//# sourceMappingURL=provider.js.map

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@sebastienrousseau/crypto-react",
+  "version": "0.0.8",
+  "description": "React hooks for client-side cryptography -- key generation, encryption, signing, and hashing in a single import.",
+  "author": "Sebastien Rousseau <sebastienrousseau@users.noreply.github.com>",
+  "license": "MIT OR Apache-2.0",
+  "homepage": "https://github.com/sebastienrousseau/crypto-service/tree/main/packages/crypto-react",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sebastienrousseau/crypto-service.git",
+    "directory": "packages/crypto-react"
+  },
+  "bugs": {
+    "url": "https://github.com/sebastienrousseau/crypto-service/issues"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map"
+  ],
+  "dependencies": {
+    "@sebastienrousseau/crypto-lib": "0.0.8"
+  },
+  "peerDependencies": {
+    "react": "^19.3.0"
+  },
+  "devDependencies": {
+    "@sebastienrousseau/mocha-config": "^0.0.5",
+    "@types/chai": "^4.3.7",
+    "@types/chai-as-promised": "^8.0.2",
+    "@types/mocha": "^10.0.2",
+    "@types/node": "^26.6.3",
+    "@types/react": "^19.3.0",
+    "c8": "^12.0.0",
+    "chai": "^4.5.0",
+    "chai-as-promised": "^7.1.2",
+    "mocha": "^10.8.2",
+    "react": "^19.3.0",
+    "rimraf": "^6.1.3",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.28.20",
+    "typescript": "~5.9.3"
+  },
+  "keywords": [
+    "react",
+    "hooks",
+    "cryptography",
+    "encryption",
+    "signing",
+    "hashing",
+    "keygen",
+    "crypto"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "private": false,
+  "scripts": {
+    "build": "tsc --build tsconfig.json",
+    "clean": "rimraf ./coverage ./dist ./docs",
+    "test": "c8 --check-coverage --lines 100 --branches 100 --functions 100 --reporter=lcov --reporter=text mocha --config=.mocharc.cjs",
+    "docs": "typedoc",
+    "lint": "eslint --ext .ts src __tests__",
+    "lint:fix": "eslint --cache --fix --ext .ts src __tests__",
+    "format": "prettier --write src/**/*.ts",
+    "format:check": "prettier --check \"src/**/*.ts\""
+  }
+}