open-index/open-npm huggingface dataset:
npm package: @reiterate/react
Description: Library to send feedback to Reiterate.so for React.
Latest version: 0.0.4

# Reiterate.so

## Installation

```bash
yarn add @reiterate/react

or

npm add @reiterate/react

```

## Usage

```tsx
const YourComponent = ({ userId }: { userId: string }) => {
  const [text, setText] = useState('')
  const { create } = useFeedback({ userId })

  return (
    <>
      <textarea
        value={text}
        onChange={(e) => setText(e.target.value)}
      ></textarea>
      <button onClick={create(text)}>Feedback</button>
    </>
  )
}
```
npm package: @reitlepax/streak-counter
Description: This is a basic streak counter - inspired by Duolingo - written in Typescript and meant for the browser (uses `localStorage`).
Latest version: 0.0.1

# `@reitlepax/streak-counter` - a basic streak counter

This is a basic streak counter - inspired by Duolingo - written in Typescript and meant for the browser (uses `localStorage`).

## Install

```shell
yarn add @reitlepax/streak-counter
```

```shell
npm install @reitlepax/streak-counter
```

## Usage

import { streakCounter } from '@reitlepax/streak-counter'

const today = new Date();
const streak = streakCounter(localStorage, today);
// streak returns an object:
// {
// currentcount: 1,
// lastLoginDate: "11/11/2021",
// startDate: "11/11/2021",
// }
npm package: @reiwa/dark
Description: [![npm version](https://badge.fury.io/js/%40reiwa%2Fdark.svg)](https://badge.fury.io/js/%40reiwa%2Fdark)
Latest version: 1.0.3

# @reiwa/dark

[![npm version](https://badge.fury.io/js/%40reiwa%2Fdark.svg)](https://badge.fury.io/js/%40reiwa%2Fdark)

## Installation

```
$ yarn add @reiwa/dark
```

## Usage

```ts
import React, { FunctionComponent } from 'react'
import { useDarkMode } from '@reiwa/dark'

const App: FunctionComponent = () => {
  const darkMode = useDarkMode()

  return <p>{darkMode ? 'Dark Mode' : 'Light Mode'}</p>
}
```
npm package: @reix/bits
Description: Bit related utilities for the eix game engine
Author: Mateiadrielrafael
Latest version: 0.2.2

# `Bits`

> Bit-related utilites for the reix game engine

## Usage

### BitFieldEmitter

```ts
import { BitFieldEmitter } from '@reix/bits'

// create emitter
const emitter = new BitFieldEmitter<number>()

// each listener gets a data and a code parameter
const handler = (data: number, code: number) => console.log('fired')

emitter.on(0b011, handler)

// second param can be any number you want to pass to the handlers, I just like the digit 7:)
emitter.emit(0b001, 7) // fired
emitter.emit(0b100, 7) // nothing...
emitter.emit(0b101, 7) // fired
emitter.emit(0b110, 7) // fired
```
npm package: @reix/ecs
Description: Entity component system for the reix game engine
Author: Mateiadrielrafael
Latest version: 0.2.1

# `ecs`

This package is still in development. [Contributions](https://github.com/Mateiadrielrafael/reix) are welcome!

## Usage

```
const ecs = require('ecs');

// TODO: DEMONSTRATE API
```
npm package: @reix/rxjs-bits
Description: Rxjs integration for the @reix/bits package.
Author: Mateiadrielrafael
Latest version: 0.1.2

# `rxjs-bits`

> Rxjs integration for the @reix/bits package.

## Usage

This package requires both `rxjs` and `@reix/bits` as peer dependencies.

```ts
import { toSubjects } from '@reix/rxjs-bits'
import { BitFieldEmitter } from '@reix/bits'

const myEventCode = 2

const emitter = new BitFieldEmitter<number>()
const { on$, emit$, dispose } = toSubjects(emitter, myEventCode)

on$.subscribe(({ value, code }) => {
    console.log(`Fired with value ${value} and code ${code}`)
})

emitter.emit(myEventCode, 2) // Fired with value 7 and code 2

emit$.next({
    value: 7
}) // Fired with value 7 and code 2

emit$.next({
    value: 7,
    code: myEventCode | 4
}) // Fired with value 7 and code 6

// do cleanup
dispose()
```
npm package: @reizt/dynamorisma
Description: Prisma-like AWS DynamoDB ORM
Author: reizt
Latest version: 0.0.0-alpha.1

Prisma-like AWS DynamoDB ORM

## Getting Started

```sh
npm i @reizt/dynamorisma
```

## Example

```ts
import { dynamorisma, type DynamorismaSchema } from '@reizt/dynamorisma';

const config = {
	user: {
		id: { type: 'S', gsi: { readCapacityUnits: 2, writeCapacityUnits: 2 } },
		name: { type: 'S', optional: true },
		age: { type: 'N', gsi: {} },
		sex: { type: 'S', enum: ['male', 'female'] as const },
	},
} satisfies DynamorismaSchema;

const client = dynamorisma(config, {
	clientConfig: {},
	tableName: 'xxx',
	options: {
		log: {
			query: true,
		},
	},
});

await client.user.$many({
	where: { OR: [{ id: { eq: 'xxx' } }, { name: { contains: 'foo' } }] },
	scanLimit: 10,
	gsi: 'id',
});
const user = await client.user.$one({
	where: { OR: [{ id: { eq: 'xxx' } }, { name: { contains: 'foo' } }] },
});

if (user == null) {
	throw new Error('user not found');
}

const updatedUser = await client.user.update({
	...user,
	age: user.age + 1,
});

await client.user.$delete(updatedUser.__dynamorismaId);
```
npm package: @reizt/proc
Description: Simplify Next.js backend using zod.
Author: reizt
Latest version: 2.0.2

# @reizt/proc

Simplify Next.js backend using zod.

## Installation

```sh
npm install @reizt/proc @reizt/proc-nextjs
```

## Usage

> `~/*` is mapped to `src/*` in `tsconfig.json`

1. Define an endpoint definition that satisfies `Proc` interface

`src/procs/get-full-name.ts`

```ts
import type { Proc } from '@reizt/proc';
import { z } from 'zod';

export const getFullName = {
  method: 'get',
  path: '/full-name',
  input: z.object({
    firstName: z.string().min(1).max(10),
    lastName: z.string().min(1).max(10),
  }),
  output: z.object({
    fullName: z.string(),
  }),
  errors: {
    black_listed: 'bad_request',
  },
} satisfies Proc;
```

2. Implement the procedure

`src/backend/get-full-name.ts`

```ts
import { type ProcImpl, err, ok } from '@reizt/proc/server';
import type { getFullName } from '~/procs/get-full-name';

export const getFullNameImpl: ProcImpl<typeof getFullName> = async (input, meta) => {
  if (input.firstName === 'John') {
    return err('black_listed');
  }
  return ok({
    fullName: `${input.firstName} ${input.lastName}`,
  });
};
```

3. Define routes

`src/app/api/[[...all]]/route.ts`

```ts
import { registerProcs } from '@reizt/proc/server';
import { Hono } from 'hono';
import { handle } from 'hono/vercel';
import { getFullName } from '~/procs/get-full-name';
import { getFullNameImpl } from '~/backend/get-full-name';

const app = new Hono().basePath('/api');

registerProcs(app, (register) => {
  register(getFullName, getFullNameImpl);
});

export const GET = handle(app);
export const POST = handle(app);
```

4. Call the procedure from client-side

`src/app/ClientComponent.tsx`

```tsx
'use client';
import type { ProcResult } from '@reizt/proc';
import { useEffect, useState } from 'react';
import { getFullName } from '~/procs/get-full-name';

const api = new ProcRemoteClient('http://localhost:3000/api');

export function ClientComponent() {
  const [result, setResult] = useState<ProcResult<typeof getFullName> | null>(null);

  useEffect(() => {
    api.call(getFullName, { firstName: 'Michael', lastName: 'Jackson' }).then(setResult);
  }, []);

  if (result == null) {
    return <div>Loading...</div>;
  }

  if (!result.success) {
    return <div>Error: {result.error}</div>
  }

  return <div>Output: {result.output.fullName}</div>
}
```

5. Call the procedure from server-side

```tsx
import { directCallProc } from '@reizt/proc/server';
import { getFullName } from '~/procs/get-full-name';
import { getFullNameImpl } from '~/backend/get-full-name';

export async function ServerComponent() {
  const result = await directCallProc(getFullName, getFullNameImpl, {
    firstName: 'Michael',
    lastName: 'Jackson',
  });

  if (!result.success) {
    return <div>Error: {result.error}</div>
  }

  return <div>Output: {result.output.fullName}</div>
}
```

By running `npm run test.next`, you can run a sample app.
npm package: @rejchev/react-string-binder
Description: <h1 align=center>React String Binder</h1>  <div align=center>
Author: rejchev
Latest version: 1.2.0

<h1 align=center>React String Binder</h1> 
<div align=center>

[![CI](https://github.com/rejchev/react-string-binder/actions/workflows/ci.yml/badge.svg)](https://github.com/rejchev/react-string-binder/actions/workflows/ci.yml)
[![LICENSE](https://img.shields.io/github/license/rejchev/sm-jansson)](LICENSE)

</div>

## About
A simple react string binder lib.

The StringBinder allows you to replace keywords in plain text with ReactNode elements

## Install
`npm i @rejchev/react-string-binder`

## Usage
### Keywords
A keyword in plain text must start & close with `$` and contain only `A-Za-z` with out any spaces (min len = 1).

```jsx

// keyword is $keyword$
const success = `This is a $keyword$.`;

// just not handled
const fail = `This is not a $1keyword`;

// just not handled
const watch = `This is not a $key_word`;

// multiply keys: $flowers, $crons
const multiple = "$flowers$ and $crowns$.";
```
### Binds
Keys of bindable `ReactNode` | `string` must be same as keywords but without `$`

```jsx
import StringBinderInstance from "@rejchev/react-string-binder";

const text = "This is a simple $nl$";

const result = StringBinderInstance.bind(text, {
    nl: <hr />
})

```

## Usage example

```jsx

import StringBinderInstance, {StringBinderT} from "@rejchev/react-string-binder";

function App() {

  const text =
    "The spring sun warms the awakening nature. $n$" +
    "Birds chirp joyfully in the tree $crowns$, $flowers$ stretch towards the heavenly surface. $n$" +
    "The air is filled with freshness and the aroma of the first flowers."

  const unknownKeys =
    // Test variant <br/>
    "Test $variant$ $n$" +

    // Test another_variant <br/>
    "Test another_$variant$ $n$" +

    // Test third_variant_variant
    "Test third_$variant$_variant"

  const oneMore =
    // Test <a href="//yandex.ru" target="_blank">flowers</a>flowers <br/>
    "Test $flowers$flowers $n$" +

    // Test <a href="//yandex.ru" target="_blank">flowers</a>flowers <br/>
    "Test $flowers$flowers$ $n$" +

    // Test <a href="//yandex.ru" target="_blank">flowers</a><a href="//yandex.ru" target="_blank">flowers</a> <br/>
    "Test $flowers$$flowers$ $n$"

  const binder : StringBinderT = {
    crowns: <a href={'//google.com'} target={'_blank'}>crowns</a>,
    flowers: <a href={'//yandex.ru'} target={'_blank'}>flowers</a>,
    n: <br/>,
  }

  return (
    <>
      <p className="read-the-docs">
        {StringBinderInstance.bind(text, binder)}
      </p>
      <p className="read-the-docs">
        {StringBinderInstance.bind(unknownKeys, binder)}
      </p>
      <p className="read-the-docs">
        {StringBinderInstance.bind(oneMore, binder)}
      </p>
    </>
  )
}
```
npm package: @rejected-media/create-podcast-framework
Description: Scaffolding tool for creating new podcast framework projects
Author: Rex Kirshner
Latest version: 0.1.11

# @rejected-media/create-podcast-framework

Scaffolding tool for creating new podcast framework projects via `npm create`.

## Usage

### Create a new project

```bash
# Using npm
npm create @rejected-media/podcast-framework my-podcast

# Using npx
npx @rejected-media/create-podcast-framework my-podcast

# Interactive (will prompt for project name)
npm create @rejected-media/podcast-framework
```

### Options

All options from `@rejected-media/podcast-framework-cli create` are supported:

```bash
# Skip npm install
npm create @rejected-media/podcast-framework my-podcast --skip-install

# Use specific template
npm create @rejected-media/podcast-framework my-podcast --template advanced
```

## What It Does

This package is a thin wrapper around `@rejected-media/podcast-framework-cli` that enables the standard `npm create` pattern.

When you run `npm create @rejected-media/podcast-framework`, it:

1. Installs this package temporarily
2. Executes the wrapper script
3. Calls `podcast-framework create` with your arguments
4. Creates a complete podcast project with:
   - Astro project structure
   - Sanity CMS configuration
   - Framework components and utilities
   - Configuration files
   - Sample content

## What Gets Created

```
my-podcast/
├── src/
│   ├── pages/
│   │   └── index.astro
│   └── components/
├── public/
├── sanity/
│   └── schemas/
├── package.json
├── podcast.config.js
├── astro.config.mjs
├── .env.template
└── README.md
```

## Next Steps After Creation

1. Navigate to your project: `cd my-podcast`
2. Install dependencies: `npm install`
3. Set up Sanity CMS at https://sanity.io/manage
4. Copy `.env.template` to `.env.local`
5. Add your Sanity project ID and credentials
6. Start development: `npm run dev`

## Documentation

- [Framework Documentation](https://github.com/rejected-media/podcast-framework)
- [CLI Documentation](../cli/README.md)
- [Getting Started Guide](../../docs/getting-started.md)

## How It Works

This package implements npm's `npm create` pattern:

- `npm create foo` → Runs `npx create-foo`
- `npm create @scope/foo` → Runs `npx @scope/create-foo`

So `npm create @rejected-media/podcast-framework` runs `npx @rejected-media/create-podcast-framework`, which invokes the CLI's `create` command.

## For Developers

### Local Development

```bash
# Install dependencies
npm install

# Build the package
npm run build

# Test locally
npm link
cd /tmp
npm create @rejected-media/podcast-framework test-project
```

### Publishing

```bash
# Build first
npm run build

# Publish to npm
npm publish
```

The `prepublishOnly` script automatically runs `npm run build` before publishing.

## License

MIT - see [LICENSE](../../LICENSE)

## Related Packages

- [@rejected-media/podcast-framework-cli](../cli) - Full CLI tool with all commands
- [@rejected-media/podcast-framework-core](../core) - Core components and utilities
- [@rejected-media/podcast-framework-sanity-schema](../sanity-schema) - Sanity CMS schemas