open-index/open-npm huggingface dataset:
npm package: @silenteer/run
Description: Run run is a cli to quickly test a library, either in typescript or js. Most of libraries don't expose a executable method to test in cli, and `rr` is here to solve
Latest version: 1.0.5

# rr
Run run is a cli to quickly test a library, either in typescript or js. Most of libraries don't expose a executable method to test in cli, and `rr` is here to solve

# getting started

- Add `rr` to dev dependencies like - `yarn install @silenteer/run`
- Can use `yarn rr -h` to see options

# Example

- `yarn rr ./index.ts` to call default export function without any parameters
- `yarn rr ./index.ts --at echo -a 'Hello world'` to call method `echo` of the export with `Hello world` as an argument. Argument can be added multiple times
- `yarn rr ./index.ts --at echo.start` to execute method start of the export of the `echo` instance

# Argument data types
Argument employs a simple syntax to determine data type. These are supported data types for argument

- `s:<string value>` will be use as string value
- `n:<string value>` will be put to `Number`
- `b:<string value>` will be put to `Boolean`
- `j:<string value>` will be put to `JSON.parse`

# Promise
Promise will be handled accordingly so you don't have to write a file just to wrap the first level await async
npm package: @silenteer/stato
Description: Maybe a simpler all-purpose (but mostly frontend) state machine
Author: Lagz0ne
Latest version: 1.5.1

# Stato

Stato meant "state" in Italian. Stato is built to be a simple state machine for a common usecases

Stato has only one dependency, [radix3](https://github.com/radix-ui/radix3), which is a simple router to handle events and state changes.

## Get started

state machine is a set of states and transitions between states. To get started with stato, you'll need to define 
states and those shapes

```typescript
import { State, create } from "@silenteer/stato"
import { setTimeout as sleep } from "timers/promises"

type TrafficLightState =
  | State<{ name: 'red', context: { duration: number } }>
  | State<{ name: 'yellow', context: { duration: number, next: 'red' | 'green' } }>
  | State<{ name: 'green', context: { duration: number } }>
```

The above states are defined as a union of `State` objects.

To define transitions, library provides a builder to define the transitions

```typescript
const blueprint = create<TrafficLightState>()
  .transition({
    name: 'to-yellow',
    from: ['red', 'green'],
    to: 'yellow',
    async execution({ name, context }) {
      await sleep(context.duration)
      return { name: 'yellow', context: { ...context, next: name === 'red' ? 'green' : 'red' } }
    }
  })
  .transition({
    name: 'to-red-or-green',
    from: 'yellow',
    to: ['red', 'green'],
    async execution({ name, context }) {
      await sleep(context.duration)
      return { name: context.next, context: { ...context } }
    }
  }
  .build()
```

The above transitions are defined as a builder, which is a function that takes a `State` object and returns a new `State` object.

To create an instance from the machine blueprint, you can use the `createMachine` function

Then we'll enter React world

```typescript
const trafficLight = createMachine(blueprint)


function TrafficLightContainer() {
  return <trafficLight.Provider initialState={{ name: 'red', context: { duration: 1000 } }}>
    <TrafficLight />
  </trafficLight.Provider>
}

function TrafficLight() {
  const state = trafficLight.useCurrentState()
  const dispatch = trafficLight.useDispatch()

  return <div>
    <div>{state.name}</div>
    <button onClick={() => dispatch('to-yellow')}>to yellow</button>
    <button onClick={() => dispatch('to-red-or-green')}>to red or green</button>
  </div>
```
npm package: @silentflick/keycloak-client-cjs
Description: Keycloak Admin Client compiled in CommonJS
Author: Tan Minh Ho
Latest version: 24.0.5
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# KEYCLOAK ADMIN CLIENT CJS

This package provides the Keycloak Admin Client compiled in CommonJS format along with TypeScript definitions. It offers
utilities to extract TypeScript exports, upgrade dependencies, and build the package for usage in Node.js projects.

## Usage

To upgrade and build the package, run the following command:

```
yarn run upgrade
yarn run build
```
npm package: @silentias/unilogger
Description: Simple and universal logger for Node.js and browser with colored output and optional timestamps.
Author: silentias
Latest version: 1.0.0

# Unilogger - simple and universal logger for Node.js and browser

## Features

- Works both in Node.js and browsers
- Colored console logs (red, yellow, blue, gray)
- Optional timestamps
- Enable/disable logging via `LOG_ENABLED` environment variable (Node.js only)
- Simple API: `error()`, `warn()`, `info()`, `print()`
- Default instance ready for quick use

## Install 

npm install @silentias/unilogger

or 

download index.js file

## Usage

```
import { log } from '@silentias/unilogger';

log.error("Error!");
log.warn("Warning");
log.info("Information");
log.print("Print");
```

## Creating your own instance with options

```
import { Log } from '@silentias/unilogger';

const myLog = new Log({ showTimestamp: false, enabled: true });
myLog.info("Without timestamp");
```

## Support

Supports ES2022 (ES13) and later
npm package: @silentsheet/core
Description: a quiet space to write.
Author: Hamza Saleem
Latest version: 0.2.1

# @silentsheet/core

core functionality for silentsheet - a minimalist text editor.

## installation

```bash
npm install @silentsheet/core
```

## usage

```typescript
import { SilentSheet } from '@silentsheet/core';

// Create a new instance with optional initial state
const editor = new SilentSheet({
  content: 'Hello world',
  theme: 'light'
});

// Get current state
const state = editor.getState();

// Get actions
const actions = editor.getActions();

// Subscribe to UI changes
const unsubscribe = editor.subscribeToUI(() => {
  console.log('UI updated:', editor.getState());
});

// Example: Set content and save it
actions.setContent('New content');
actions.saveContent();

// Example: Toggle timer
actions.toggleTimer(); // Starts 15-minute timer
actions.resetTimer();  // Resets to 15:00

// Cleanup
unsubscribe();
```

## features

- automatic settings persistence in localStorage
- manual content persistence via `saveContent()`
- 15-minute focus timer with start/stop/reset
- four sizes (small, medium, large, full)
- font size control (number)
- three themes (light, sepia, night)
- three font families (serif, sans-serif, monospace)
- typescript support

## api

### constructor

```typescript
new SilentSheet(initialState?: Partial<SilentSheetState>)
```

Creates a new editor instance. The `initialState` is optional and will override both defaults and any saved state from localStorage. Timer state (running/seconds) is always reset on initialization.

### state

```typescript
interface SilentSheetState {
  content: string;
  font: 'serif' | 'sans-serif' | 'monospace';
  fontSize: number;
  theme: 'light' | 'sepia' | 'night';
  size: 'small' | 'medium' | 'large' | 'full';
  timerRunning: boolean;
  timerSeconds: number;
}
```

Default values:
```typescript
{
  content: '',
  font: 'sans-serif',
  fontSize: 24,
  theme: 'sepia',
  size: 'medium',
  timerRunning: false,
  timerSeconds: 900 // 15 minutes
}
```

### methods

- `getState(): SilentSheetState` - Get current state
- `getActions(): SilentSheetActions` - Get available actions
- `subscribeToUI(callback: () => void): () => void` - Subscribe to UI changes, returns unsubscribe function

### actions

- `setContent(content: string)` - Update content (does not auto-save)
- `saveContent()` - Save current content to localStorage
- `clearContent()` - Clear and save empty content
- `setFont(font: Font)` - Change font family (auto-saves)
- `setFontSize(size: number)` - Change font size (auto-saves)
- `setTheme(theme: Theme)` - Change theme (auto-saves)
- `setSize(size: Size)` - Change size (auto-saves)
- `toggleTimer()` - Start timer (15:00) or stop and reset if running
- `resetTimer()` - Stop timer and reset to 15:00

## storage

The editor uses localStorage with key 'silentsheet' to persist state. All UI settings (font, fontSize, theme, size) are automatically saved when changed. Content must be explicitly saved using `saveContent()`.

## license

mit © [hamza saleem](https://github.com/hamzasaleem2)
npm package: @silentsheet/react
Description: React component for silentsheet.
Author: Hamza Saleem
Latest version: 0.2.1

# @silentsheet/react

react component for silentsheet - a minimalist text editor.

## installation

```bash
npm install @silentsheet/core @silentsheet/react
```

## usage

```tsx
import { SilentSheet } from '@silentsheet/react';
// Don't forget to import the styles
import '@silentsheet/react/dist/index.css';

function App() {
  return (
    <SilentSheet
      placeholder="Begin your story here..."
      onChange={(text) => console.log(text)}
    />
  );
}
```

## props

```typescript
interface Props {
  // custom placeholder text (default: "Begin your story here...")
  placeholder?: string;
  
  // callback when content changes
  onChange?: (text: string) => void;
}
```

## features

- minimal toolbar that appears on hover
- three beautiful themes (light, sepia, night)
- three font families (monospace, sans-serif, serif)
- four sizes (small: 50%, medium: 75%, large: 90%, full: 100%)
- font size control (14-28px)
- 15-minute focus timer with start/stop/reset
- word and character count
- automatic content saving (1s debounce + on blur)
- automatic settings persistence
- subtle "open source" link in top-right
- fully responsive design
- typescript support

## defaults

The component uses these defaults from @silentsheet/core:
```typescript
{
  font: 'sans-serif',
  fontSize: 24,
  theme: 'sepia',
  size: 'medium'
}
```

## styling

The component requires the CSS file to be imported for proper styling:

```tsx
import '@silentsheet/react/dist/index.css';
```

## license

mit © [hamza saleem](https://github.com/hamzasaleem2)
npm package: @silentsilas/vite-plugin-ai-robots
Description: Vite plugin to automatically update your robots.txt via Dark Visitor API to block the latest list of AI user agents
Author: silentsilas
Latest version: 1.0.1

# @silentsilas/vite-plugin-ai-robots

[![npm version](https://img.shields.io/npm/v/@silentsilas/vite-plugin-ai-robots.svg)](https://www.npmjs.com/package/@silentsilas/vite-plugin-ai-robots)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)

Vite plugin that automatically generates and updates a `robots.txt` file blocking AI agents using the [Dark Visitors](https://darkvisitors.com/) API.

## Installation

Create a free account at [Dark Visitors](https://darkvisitors.com/) and obtain your access token.

```bash
npm install @silentsilas/vite-plugin-ai-robots --save-dev
```

Add the token to your environment, and pass it to the plugin's config. You should now see a `robots.txt` file in your output directory during builds.

## Usage

### Basic Configuration

```typescript
// vite.config.ts
import { defineConfig } from "vite";
import { aiRobots } from "@silentsilas/vite-plugin-ai-robots";

export default defineConfig({
  plugins: [
    aiRobots({
      accessToken: process.env.DARK_VISITORS_TOKEN,
    }),
  ],
});
```

## Configuration Options

| Option          | Type       | Default                                        | Description             |
| --------------- | ---------- | ---------------------------------------------- | ----------------------- |
| **accessToken** | `string`   | _Required_                                     | Dark Visitors API token |
| `agentTypes`    | `string[]` | `["AI Data Scraper", "Undocumented AI Agent"]` | Agent types to block    |
| `disallow`      | `string`   | `"/"`                                          | Paths to disallow       |
| `cacheHours`    | `number`   | `24`                                           | Cache duration in hours |
| `outputDir`     | `string`   | `"static"`                                     | Output directory        |
| `debug`         | `boolean`  | `false`                                        | Enable debug logging    |

## Troubleshooting

**Common Issues**:

- `401 Unauthorized`: Check your access token
- Empty robots.txt: Enable `debug: true`
- Cache not updating: Delete `.ai-robots-cache.json`
  - You may want to add this file to your .gitignore
npm package: @silentswap/react
Description: React hooks and utilities for integrating with SilentSwap SDK.
Latest version: 0.1.56

# @silentswap/react

React hooks and utilities for integrating with SilentSwap SDK.

## Installation

```bash
bun add @silentswap/react @silentswap/sdk
```

## Usage

```tsx
import { useSilentClient, useSilentOrders, useAuth } from '@silentswap/react';

function MyComponent() {
    // Create client
    const { client } = useSilentClient({
        config: {
            environment: 'MAINNET',
        },
    });

    // Use order operations
    const { getQuote, createOrder, isLoading, error } = useSilentOrders({
        client,
    });

    // Use auth utilities
    const { createSignInMessage, createEip712DocForOrder } = useAuth();

    // ... your component logic
}
```

## Hooks

### `useSilentClient`

Creates and manages a SilentSwap client instance.

### `useSilentOrders`

Provides methods for order operations including quotes, authentication, and order creation.

### `useAuth`

Provides authentication utilities for sign-in messages and EIP-712 document creation.
npm package: @silentswap/vue
Description: Vue 3 composables for integrating with SilentSwap SDK.
Latest version: 0.1.56

# @silentswap/vue

Vue 3 composables for integrating with SilentSwap SDK.

## Installation

```bash
npm install @silentswap/vue
# or
bun add @silentswap/vue
# or
yarn add @silentswap/vue
```

## Usage

### getSilentSwapClient

Create and manage a SilentSwap client instance:

```typescript
import { getSilentSwapClient } from '@silentswap/vue';

const { client } = getSilentSwapClient({
  config: {
    baseUrl: 'https://api.silentswap.com',
  },
});
```

### getSilentSwapAuth

Handle authentication utilities:

```typescript
import { getSilentSwapAuth } from '@silentswap/vue';

const {
  createSignInMessage,
  createEip712DocForOrder,
  createEip712DocForWalletGeneration,
} = getSilentSwapAuth();

// Create a sign-in message
const message = createSignInMessage('0x...', 'nonce123', 'app.silentswap.com');

// Create EIP-712 document for order
const orderDoc = createEip712DocForOrder(quoteResponse);

// Create EIP-712 document for wallet generation
const walletDoc = createEip712DocForWalletGeneration('scope', 'token');
```

### getSilentSwapOrders

Manage orders and related operations with reactive state:

```typescript
import { getSilentSwapOrders } from '@silentswap/vue';

const { client } = getSilentSwapClient({ config: yourConfig });

const {
  isLoading,
  error,
  getNonce,
  authenticate,
  getQuote,
  createOrder,
} = getSilentSwapOrders({ client });

// Get nonce for authentication
const nonce = await getNonce('0x...');

// Authenticate user
const authResult = await authenticate({
  address: '0x...',
  signature: '0x...',
  message: '...',
});

// Get a quote
const quote = await getQuote({
  sellToken: '0x...',
  buyToken: '0x...',
  sellAmount: '1000000000000000000',
});

// Create an order
const order = await createOrder({
  quoteId: quote.quoteId,
  signature: '0x...',
});
```

## API Reference

### getSilentSwapClient

#### Parameters

- `config: SilentSwapClientConfig` - Configuration for the SilentSwap client

#### Returns

- `client: SilentSwapClient` - The SilentSwap client instance

### getSilentSwapAuth

#### Returns

- `createSignInMessage(address, nonce, domain?)` - Create a sign-in message
- `createEip712DocForOrder(quoteResponse)` - Create EIP-712 typed data for order
- `createEip712DocForWalletGeneration(scope, token)` - Create EIP-712 typed data for wallet generation

### getSilentSwapOrders

#### Parameters

- `client: SilentSwapClient` - The SilentSwap client instance

#### Returns

- `isLoading: boolean` - Reactive loading state
- `error: Error | null` - Reactive error state
- `getNonce(address)` - Get nonce for authentication
- `authenticate(auth)` - Authenticate user
- `getQuote(quote)` - Get a quote
- `createOrder(order)` - Create an order

## Requirements

- Vue 3.0+
- TypeScript (recommended)