open-index/open-npm huggingface dataset:
npm package: @seliseblocks/released-notes
Description: Released Notes is an Angular package that enables easy integration and display of release notes in Angular applications.
Latest version: 0.0.6

# Released Notes

Released Notes is an Angular package that enables easy integration and display of release notes in Angular applications.

## Purpose

The primary purpose of the `released-notes` package is to offer a seamless solution for showcasing release notes within Angular applications. Whether you're managing frequent updates, major releases, or periodic bug fixes, this package provides an easy-to-use module that enhances communication between development teams and end-users.

By integrating `released-notes` into your Angular project, you empower your application with a visually appealing and customizable component for displaying release notes. This helps improve transparency, user experience, and collaboration within your development community.

## Installation

```bash
npm install released-notes
```

## Usage
Add the ReleasedNotesModule to the imports of the module which will be viewing the
released notes.

```node
import { ReleasedNotesModule } from 'released-notes';

@NgModule({
  imports: [
    // other modules
    ReleasedNotesModule.forRoot({
      Oid: 'your-organization-id',
      environment: yourAngularEnvironment, // Optional
    }),
  ],
})
export class YourModule {}

```
Add the element to your HTML:

```
<released-note></released-note>

```
npm package: @selix/adapter-express
Description: Express adapter for Selix.
Latest version: 0.2.0

# @selix/adapter-express

Express adapter for Selix.

## Installation

```bash
npm install @selix/adapter-express express
# or
bun add @selix/adapter-express express
```

## Usage

```typescript
import express from 'express';
import { createExpressMiddleware } from '@selix/adapter-express';
import { appRouter } from './router';

const app = express();
app.use(express.json()); // Ensure JSON body parsing is enabled

app.use('/api', createExpressMiddleware({
    router: appRouter,
    createContext: ({ req, res }) => {
        // Return your context here
        return {
            authHeader: req.headers.authorization
        };
    }
}));

app.listen(3000, () => {
    console.log('Server is running on http://localhost:3000');
});
```
npm package: @selix/adapter-hono
Description: Hono adapter for Selix.
Latest version: 0.2.0

# @selix/adapter-hono

Hono adapter for Selix.

## Installation

```bash
npm install @selix/adapter-hono hono
# or
bun add @selix/adapter-hono hono
```

## Usage

```typescript
import { Hono } from 'hono';
import { selixMiddleware } from '@selix/adapter-hono';
import { appRouter } from './router';

const app = new Hono();

app.all('/api/*', selixMiddleware(appRouter));

export default app;
```

### With Context

```typescript
import { createHonoMiddleware } from '@selix/adapter-hono';

app.use('/api/*', createHonoMiddleware({
    router: appRouter,
    createContext: ({ c }) => {
        return {
            userAgent: c.req.header('User-Agent')
        };
    }
}));
```
npm package: @selix/client
Description: The vanilla client for Selix. Use this to consume your Selix backend in any JavaScript/TypeScript environment.
Latest version: 0.2.0

# @selix/client

The vanilla client for Selix. Use this to consume your Selix backend in any JavaScript/TypeScript environment.

## Installation

```bash
npm install @selix/client
# or
bun add @selix/client
```

## Usage

### Create Client

```typescript
import { createClient } from '@selix/client';
import type { AppRouter } from './backend'; // Import your AppRouter type

const client = createClient<AppRouter>({
    url: 'http://localhost:3000/api', // Your backend URL
    debugMode: true // Optional: enables logging of requests/responses
});
```

### Querying

```typescript
const result = await client.greeting.query({ 
    input: { name: 'World' } 
});
console.log(result.message);
```

### Mutations

```typescript
const response = await client.createUser.mutation({ 
    input: { email: 'user@example.com' } 
});
```
npm package: @selix/core
Description: The core package for Selix, a type-safe backend framework. This package provides the runtime for defining routers and procedures.
Latest version: 0.2.0

# @selix/core

The core package for Selix, a type-safe backend framework. This package provides the runtime for defining routers and procedures.

## Installation

```bash
npm install @selix/core zod
# or
yarn add @selix/core zod
# or
pnpm add @selix/core zod
# or
bun add @selix/core zod
```

## Usage

### Initialize Selix

```typescript
import { initSelix } from '@selix/core';

const t = initSelix();
```

### Context

Define your context type (optional but recommended for authentication, etc.):

```typescript
export type Context = {
    user?: { id: string };
};

const t = initSelix<Context>();
```

### Procedures

Define queries and mutations with Zod validation.

```typescript
import { z } from 'zod';

export const appRouter = t.router({
    greeting: t.procedure
        .input(z.object({ name: z.string() }))
        .query(({ input, ctx }) => {
            return {
                message: `Hello ${input.name}`,
                userId: ctx.user?.id
            };
        }),
    
    createUser: t.procedure
        .input(z.object({ email: z.string().email() }))
        .mutation(({ input }) => {
            // database logic here
            return { success: true, email: input.email };
        })
});

export type AppRouter = typeof appRouter;
```
npm package: @selix/react-query
Description: TanStack Query adapter for Selix. This package allows you to use your Selix router with React Query hooks.
Latest version: 1.0.0

# @selix/react-query

TanStack Query adapter for Selix. This package allows you to use your Selix router with React Query hooks.

## Installation

```bash
npm install @selix/react-query @selix/client @tanstack/react-query
# or
bun add @selix/react-query @selix/client @tanstack/react-query
```

## Usage

### 1. Create the React Client

```typescript
// utils/selix.ts
import { createSelixReact } from '@selix/react-query';
import type { AppRouter } from '../backend/router';

export const selix = createSelixReact<AppRouter>();
```

### 2. Setup Provider

Wrap your application with `SelixProvider` and `QueryClientProvider`.

```tsx
// App.tsx
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { createClient } from '@selix/client';
import { SelixProvider } from '@selix/react-query';
import { selix } from './utils/selix';

const queryClient = new QueryClient();

// Create the vanilla client
const selixClient = createClient({
    url: 'http://localhost:3000/api',
});

export default function App() {
    return (
        <QueryClientProvider client={queryClient}>
            <SelixProvider client={selixClient}>
                <YourComponent />
            </SelixProvider>
        </QueryClientProvider>
    );
}
```

### 3. Use Hooks

```tsx
import { selix } from './utils/selix';

function YourComponent() {
    const hello = selix.greeting.useQuery({ 
        input: { name: 'World' } 
    });
    
    const createUser = selix.createUser.useMutation();

    if (hello.isLoading) return <div>Loading...</div>;

    return (
        <div>
            <p>{hello.data?.message}</p>
            <button onClick={() => createUser.mutate({ input: { email: 'test@example.com' } })}>
                Create User
            </button>
        </div>
    );
}
```