open-index/open-npm huggingface dataset:
npm package: @nvd/tsconfig
Description: Shared TypeScript config for my projects
Author: Nick Van Dyck
Latest version: 1.0.0

# tsconfig

> Shared [TypeScript config](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html) for my projects


## Install

```
$ npm install --save-dev @nvd/tsconfig
```


## Usage

`tsconfig.json`

```json
{
	"extends": "@nvd/tsconfig",
	"compilerOptions": {
		"outDir": "dist",
		"target": "es2018",
		"lib": [
			"es2018"
		]
	}
}
```
npm package: @nvd/use-webgl
Description: React hook utility to create a webgl context
Author: Nick Van Dyck
Latest version: 0.1.0

# useWebGL
[React Hook](https://reactjs.org/docs/hooks-overview.html) to get access to a webgl context and manage canvas life cycle

## Installation

```sh
# Yarn
yarn add @nvd/use-webgl

# NPM
npm i --save @nvd/use-webgl
```

## Usage
> This utility depends on React Hooks which are available as of react version 16.8.0 and higher.

```tsx
import React from "react"
import { render } from "react-dom"
import {createStore} from "redux"
import { useWebGL } from "@nvd/use-webgl"

const App = () => {
    const [canvas, resizeCanvas] = useWebGL({ width: 250, height: 250 })

    return (
        <div> { canvas } </div>
    );
}

render(
    <App />,
    document.getElementById('root'),
)

```

## API

### useWebGL
> (options: UseWebGLOptions) =&#x3E; (JSX.Element | ((newWidth: number, newHeight: number) =&#x3E; void))[];

Create a canvas and provide access to a webgl context object.

```tsx

const App = () => {
    const [ canvas, resizeCanvas] = useWebGL({
        width: 100,
        height: 100,
        onInit,
        onResize,
        onExit
    })

    ...
}
```

### UseWebGLOptions
Configuration object given to `useWebGL` function. Width and height are passed to the canvas to set up the initial size. onInit, onExit and onResize function are life cycle hooks that are used to do set up, cleanup or update your view for those events. Only width, height and onInit are required

```ts
declare type UseWebGLOptions = {
    width: number;
    height: number;
    onInit: (GL: WebGLRenderingContext | null, canvas: HTMLCanvasElement) => void;
    onExit?: () => void;
    onResize?: (width: number, height: number) => void;
};
```

## License
MIT
npm package: @nve-org/vue-components
Description: NVE's standard komponentbibliotek er implementert som web-components. Mer info om dette finner du her: https://designsystem.nve.no/ . Dette prosjektet inneholder komponenter som bygger på NVE sitt designsystem, men som blir ansett som for komplekse til å 
Author: IUR NVE
Latest version: 2.0.0

# @nve-org/vue-components

Vue-komponenter som bygger på [NVE Designsystem](https://designsystem.nve.no/), men som er for komplekse til å implementeres som rene web-komponenter.

## Installasjon

```bash
npm install @nve-org/vue-components
```

## Bruk i Vue 3-prosjekter

### Importstruktur: Global vs. Lokal bruk

Biblioteket støtter både `global registrering` (hele pakken) og `lokal import` (enkeltkomponenter). Dette gir fleksibilitet i forskjellige prosjektstørrelser og behov.

#### Alternativ 1: Global registrering (app.use)

Registrerer `alle komponenter automatisk globalt`, slik at du slipper å importere dem én og én.

```ts
// main.ts eller main.js
import { createApp } from 'vue'
import App from './App.vue'
import NVEComponents from '@nve-org/vue-components'

const app = createApp(App)
app.use(NVEComponents)
app.mount('#app')
```

##### Bruk i komponenter uten import

```ts
<template>
  <NveTable :headers="headers" :data="countries" />
</template>

<script setup lang="ts">
// Ingen import av NveTable nødvendig!
</script>
```

#### Alternativ 2: Lokal import (tree-shaking)

Bare komponentene du faktisk bruker blir inkludert i bundlen – ideelt for optimal ytelse.

```ts
<template>
  <NveTable :headers="headers" :data="countries" />
</template>

<script setup lang="ts">
import { NveTable } from '@nve-org/vue-components'
</script>
```

### Eksempel: Bruk av NveTable

```ts
<script setup lang="ts">
import { ref } from 'vue'
import { NveTable } from '@nve-org/vue-components'

type Country = { name: string; code: string; capital: string }

const headers = ref([
  { key: 'name', title: 'Navn' },
  { key: 'code', title: 'Kode' },
  { key: 'capital', title: 'Hovedstad' }
])

const countries = ref<Country[]>([
  { name: 'Norge', code: 'NO', capital: 'Oslo' },
  { name: 'Sverige', code: 'SE', capital: 'Stockholm' },
  { name: 'Danmark', code: 'DK', capital: 'København' }
])
</script>

<template>
  <NveTable :headers="headers" :data="countries" :item-id="(item) => item.code" striped />
</template>
```

## Lisens

MIT © NVE

## For utviklere

Hvis du skal bidra eller bygge ut biblioteket: se [CONTRIBUTING.md](./CONTRIBUTING.md)
npm package: @nvent-addon/adapter-queue-redis
Description: Redis queue adapter for nvent using BullMQ
Latest version: 0.5.15

# @nvent/adapter-queue-redis

Redis queue adapter for nvent using BullMQ.

## Installation

```bash
pnpm add @nvent/adapter-queue-redis
```

## Usage

```typescript
// nuxt.config.ts
export default defineNuxtConfig({
  modules: [
    'nvent',
    '@nvent/adapter-queue-redis'
  ],
  
  nvent: {
    queue: {
      adapter: 'redis',
      redis: {
        host: 'localhost',
        port: 6379,
        // or use url
        // url: process.env.REDIS_URL
      }
    }
  }
})
```

## Configuration

The adapter accepts all BullMQ connection options:

```typescript
nventQueueRedis: {
  connection: {
    host: 'localhost',
    port: 6379,
    username: 'default',
    password: 'your-password',
    db: 0
  },
  prefix: 'nvent', // Queue prefix
  defaultJobOptions: {
    attempts: 3,
    backoff: {
      type: 'exponential',
      delay: 1000
    }
  }
}
```

## Features

- ✅ BullMQ integration for robust job processing
- ✅ Redis-based queue storage
- ✅ Delayed and scheduled jobs
- ✅ Job retries with exponential backoff
- ✅ Queue pause/resume
- ✅ Distributed workers
- ✅ Production-ready

## License

MIT
npm package: @nvent-addon/adapter-stream-redis
Description: Redis Pub/Sub stream adapter for nvent
Latest version: 0.5.15

# @nvent/adapter-stream-redis

Redis Pub/Sub stream adapter for nvent using ioredis.

## Features

- Real-time pub/sub messaging via Redis channels
- Multiple subscribers per topic
- Automatic channel cleanup
- Topic listing and introspection

## Installation

```bash
pnpm add @nvent/adapter-stream-redis
```

## Usage

Add to your `nuxt.config.ts`:

```typescript
export default defineNuxtConfig({
  modules: [
    'nvent',
    '@nvent/adapter-stream-redis'
  ],
  
  nvent: {
    stream: {
      adapter: 'redis'
    }
  },
  
  nventStreamRedis: {
    connection: {
      host: 'localhost',
      port: 6379,
      password: process.env.REDIS_PASSWORD,
      db: 0
    },
    prefix: 'nvent'
  }
})
```

## Configuration

### Connection Options

- `host` - Redis host (default: 'localhost')
- `port` - Redis port (default: 6379)
- `username` - Redis username
- `password` - Redis password
- `db` - Database number (default: 0)

### Adapter Options

- `prefix` - Prefix for Redis channels (default: 'nvent')

## How It Works

The adapter creates Redis Pub/Sub channels for each topic:

```
{prefix}:stream:{topic}
```

With the default prefix `nvent`, channels look like: `nvent:stream:mytopic`

Messages are JSON-serialized StreamMessage objects with automatic retry and error handling.

## License

MIT
npm package: @nverino/tiny
Description: Removes all spaces from a string
Latest version: 1.1.1

# @nverino/tiny

![npm (scoped)](https://img.shields.io/npm/v/@nverino/tiny)

Removes all spaces from a string.

## Install

```
$ npm install @nverino/tiny
```

## Usage

```js
const tiny = require("@nverino/tiny");

tiny("So much space!");
//=> "Somuchspace!"

tiny(1337);
//=> Uncaught TypeError: Tiny wants a string!
//    at tiny (<anonymous>:2:41)
//    at <anonymous>:1:1
```
npm package: @nverk/react-native-dnd
Description: A versatile drag and drop library for React Native with gesture handling and smooth animations
Author: Nver Khachoyan
Latest version: 1.0.0

# @nverk/react-native-dnd

Lightweight Drag and Drop for React Native, powered by Reanimated & Gesture Handler

<!-- Placeholder for badges -->
<!-- ![NPM Version](...) -->
<!-- ![License](...) -->
<!-- ![Build Status](...) -->

## Overview

`@nverk/react-native-dnd` is a lightweight and performant drag-and-drop solution for React Native applications. It leverages the power of `react-native-gesture-handler` for robust gesture recognition and `react-native-reanimated` (v3 compatible) for smooth, native-feeling animations.

**Key Features:**

- Built with `react-native-gesture-handler` and `react-native-reanimated`.
- Smooth animations and precise gesture handling.
- Highly customizable drag and drop behavior.
- Lightweight and focused API.
- Type-safe with TypeScript.
- Supports snapping, swapping, capacity limits, and various drop behaviors.

## Documentation

You can find extensive documentation for the module [here](https://www.nverk.me/react-native-dnd).

## Installation

```bash
npm install @nverk/react-native-dnd
# or
yarn add @nverk/react-native-dnd
```

**Peer Dependencies:**

Ensure you have `react-native-gesture-handler` and `react-native-reanimated` installed and configured in your project.

- `react-native-gesture-handler >= 2.x.x`
- `react-native-reanimated >= 3.x.x`

Refer to their official installation guides for native setup:

- [React Native Gesture Handler Documentation](https://docs.swmansion.com/react-native-gesture-handler/docs/installation)
- [React Native Reanimated Documentation](https://docs.swmansion.com/react-native-reanimated/docs/installation) (ensure the Babel plugin is correctly set up)

**NOTE:** It's important to wrap your application with `GestureHandlerRootView` at the root, as shown in the example, for `react-native-gesture-handler` to work correctly.

## Usage

> Wrap DndProvider at the top level to preserve DND state after screen change.

```javascript
import {
  DndList,
  DndProvider,
  Draggable,
  Droppable,
} from "@nverk/react-native-dnd";
import { SafeAreaView, Text } from "react-native";
import { GestureHandlerRootView } from "react-native-gesture-handler";

export default function HomeScreen() {
  return (
    <SafeAreaView style={{ flex: 1 }}>
      <GestureHandlerRootView>
        <Text>Drag and Drop Demo</Text>
        <DndProvider>
          <DndList>
            <Droppable key={"drop1"} id={"drop1"}>
              <Text>Drop Here</Text>
            </Droppable>
            <Draggable key={"drag1"} id="drag1">
              <Text>Drag Me</Text>
            </Draggable>
          </DndList>
        </DndProvider>
      </GestureHandlerRootView>
    </SafeAreaView>
  );
}
```

There is a better example at [example](example).

## Contributing

You're free to contribute to the project if you're willing to make sense of the mess I made ;)

## License

MIT
npm package: @nvhien20vn/mcp-xmind
Description: mcp server for xmind
Author: Hien Nguyen hien.van.nguyen0408@gmail.com
Latest version: 0.0.1

# MCP XMind Server

A Model Context Protocol server for analyzing and querying XMind mind maps. This tool provides powerful capabilities for searching, extracting, and analyzing content from XMind files.

## Features

- 🔍 Smart fuzzy search across mind maps
- 📝 Task management and tracking
- 🌲 Hierarchical content navigation
- 🔗 Link and reference extraction
- 📊 Multi-file analysis
- 🏷️ Label and tag support
- 📂 Directory scanning
- 🔒 Secure directory access

## Installation

### Manual Installation
```bash
npm install @modelcontextprotocol/sdk adm-zip zod
npm install --save-dev typescript @types/node
```

## Usage

### Starting the Server

```bash
node dist/index.js <allowed-directory> [additional-directories...]
```

### Available Tools

1. **read_xmind**
   - Parse and analyze XMind files
   - Extract complete mind map structure

2. **get_todo_tasks**
   - Extract and analyze TODO tasks
   - Include task context and hierarchy

3. **list_xmind_directory**
   - Recursively scan for XMind files
   - Filter and organize results

4. **read_multiple_xmind_files**
   - Process multiple files simultaneously
   - Compare and analyze across files

5. **search_xmind_files**
   - Search files by name patterns
   - Recursive directory scanning

6. **extract_node**
   - Smart fuzzy path matching
   - Ranked search results
   - Complete subtree extraction

7. **extract_node_by_id**
   - Direct node access by ID
   - Fast and precise retrieval

8. **search_nodes**
   - Multi-criteria content search
   - Configurable search fields

## Examples

### Search for Nodes
```json
{
    "name": "search_nodes",
    "arguments": {
        "path": "/path/to/file.xmind",
        "query": "project",
        "searchIn": ["title", "notes"],
        "caseSensitive": false
    }
}
```

### Extract Node
```json
{
    "name": "extract_node",
    "arguments": {
        "path": "/path/to/file.xmind",
        "searchQuery": "Feature > API"
    }
}
```

### List Tasks
```json
{
    "name": "get_todo_tasks",
    "arguments": {
        "path": "/path/to/file.xmind"
    }
}
```

## Configuration

### Development Configuration

Example `claude_desktop_config.json` for development:

```json
{
  "xmind": {
    "command": "node",
    "args": [
      "/Users/nvhien/src/mcp-xmind/dist/index.js",
      "/Users/nvhien/XMind"
    ]
  }
}
```

### Production Configuration

Example `claude_desktop_config.json` for production using npmjs:

```json
{
  "xmind": {
    "command": "npx",
    "args": [
      "-y",
      "@nvhien20vn/mcp-xmind",
    ]
  }
}
```

## Security

- Only allows access to specified directories
- Path normalization and validation
- Error handling for invalid access attempts

## Development

### Building
```bash
npm run build
```

### Type Checking
```bash
npm run type-check
```

### MCP Inspector

```bash
npx @modelcontextprotocol/inspector node dist/index.js 
```