open-index/open-npm huggingface dataset:
npm package: @onion-az/bus
Description: To install dependencies:
Latest version: 0.0.1

# @onion-az/bus

To install dependencies:

```bash
bun install
```

To run:

```bash
bun run src/lib.ts
```

This project was created using `bun init` in bun v1.3.2. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.
npm package: @onion-az/identity
Description: A minimal, framework-agnostic identity factory for React.   You bring your own auth backend (Firebase, Supabase, custom API, anything),   and this library provides a consistent, typed, runtime-safe identity layer.
Latest version: 0.0.3

# @onion-az/identity

A minimal, framework-agnostic identity factory for React.  
You bring your own auth backend (Firebase, Supabase, custom API, anything),  
and this library provides a consistent, typed, runtime-safe identity layer.

Designed to be tiny, type-safe, and auth-provider neutral.

---

## Features

- Zero dependencies (React only)
- Bring-your-own authentication logic
- Fully typed `user` and `capabilities`
- Provider + hook API
- Works with any auth backend
- Extremely small surface area
- No assumptions about your auth model
- Universal: works with Bun, Node, Vite, and npm

---

## Installation

### npm
```bash
npm install @onion-az/identity
```

### bun
```bash
bun add @onion-az/identity
```

### pnpm
```bash
pnpm add @onion-az/identity
```

---

## Quick Start

### 1. Define your user type

```ts
// types.ts
import type { BaseUser } from "@onion-az/identity";

export interface MyUser extends BaseUser<string> {
  email: string;
  roles: string[];
}
```

Extend `BaseUser` in any way you need.

---

### 2. Create your identity instance

```ts
// identity.ts
import { createIdentityFactory } from "@onion-az/identity";
import type { MyUser } from "./types";

export const Identity = createIdentityFactory<
  MyUser,
  { logout: () => Promise<void> }
>();
```

This produces:

- `Identity.Provider`
- `Identity.useAuth()`

---

### 3. Provide the identity state

You control how your user is loaded, refreshed, and managed.

```tsx
import { Identity } from "./identity";
import { useEffect, useState } from "react";

function App() {
  const [user, setUser] = useState<MyUser | null>(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch("/api/me")
      .then(res => res.json())
      .then(setUser)
      .finally(() => setLoading(false));
  }, []);

  const capabilities = {
    logout: async () => {
      await fetch("/api/logout", { method: "POST" });
      setUser(null);
    }
  };

  return (
    <Identity.Provider
      value={{
        user,
        loading,
        error: null,
        capabilities
      }}
    >
      <AppRoutes />
    </Identity.Provider>
  );
}
```

---

## Using `useAuth()`

```tsx
import { Identity } from "./identity";

function Dashboard() {
  const { user, loading, error, capabilities } = Identity.useAuth();

  if (loading) return <p>Loading...</p>;
  if (!user) return <p>You must sign in.</p>;

  return (
    <div>
      <h1>Welcome {user.email}</h1>
      <button onClick={capabilities.logout}>Log out</button>
    </div>
  );
}
```

---

## Identity Context Shape

```ts
interface IdentityContext<TUser, TCapabilities> {
  user: TUser | null;
  loading: boolean;
  error: unknown | null;
  capabilities: TCapabilities;
}
```

You define:

- your user model  
- your roles  
- your capabilities (logout, delete account, refresh token, etc.)

---

## License

MIT © OnionAZ