open-index/open-npm huggingface dataset:
npm package: @kovsu/nc
Description: 🧁 Utils library About npm.
Author: Konv Suu
Latest version: 0.2.0

## nc

### Usage

```bash
npm i @kovsun/nc -g
```

### nc -c

View the latest version of dependencies in package.json.

<img src="./screenshot/1.jpg" />

### nc -t [...pkgName]

Check whether the dependencies in package.json require type declarations.
<img src="./screenshot/2.jpg" />
<img src="./screenshot/3.jpg" />


### nc -p [...pkgName]

Check whether the package name already exists in npm.

<img src="./screenshot/4.jpg" />
<img src="./screenshot/5.jpg" />
npm package: @kowolinho/randomid-generator
Description: This randomid-generator package helps you to get random numbers or letters from alfanumeric string by using a number as an argument.
Author: Błażej Kowol
Latest version: 1.0.1

This randomid-generator package helps you to get random numbers or letters from alfanumeric string by using a number as an argument. 

Check this out! https://www.npmjs.com/package/@kowolinho/randomid-generator
npm package: @koy/architecture
Description: An architecture for building koy app in the browser.
Author: murakami
Latest version: 0.6.8

# @koy/architecture

An architecture for building koy app in the browser.

Have yuu heard the Elm architecture? Here's the same as that.

## Usage

Now, the library export two function -- sandbox and application.

The sandbox function expects an init model、 an view that knows how to render dom by model and an node(Maybe type) that the rendered node should be mounted at.

The application function expects an init model、 an view that knows how to render dom by model、an onUrlChange funciton and an node(Maybe type) that the rendered node should be mounted at.

**Note**: onUrlChange accepts dispatch and url then you can do anything you want to do when url changed.

example here:

```js
const init = {text: 'koy'}

const view = (dispatch, model) => Element.of(
  'p',
  Element.of('button', {
    onclick: () => dispatch({key: lensProp('text'), value: 'murakami'}),
  }, 'Change Text'),
  Element.of('span', prop('text', model)),
)

// const view = (dispatch, model) => Element.of(
//   'div',
//   Element.of(
//     'p',
//     Element.of('button', {
//       onclick: () => dispatch({key: lensProp('text'), value: 'murakami'}),
//     }, 'Change Text'),
//     Element.of('span', prop('text', model)),
//   ),
//   Element.of(
//     'p',
//     Link({href: '/home'}, 'Home Link'),
//     Element.of('span', concat(prop('url', model), 'url: '))
//   ),
// )

const mRootNode = of(Maybe, document.getElementById('app'))

sandbox(init, view, mRootNode) // open your browser to see what happened

// application(init, view, curry((dispatch, url) => dispatch({
//   key: lensProp('url'),
//   value: url,
// })), mRootNode) // open your browser to see what happened
```

And you can change the view code or the init code or the onUrlChange funciton or the mRootNode that you'd like to see whatever you want.

**Node**: The dispatch function can send a message for update model.

### Dispatch Message

You can dispatch four kinds of message:

* lensMessage -- format is {key: Lens, value: Data | Function}
* IOMessage -- format is of(IO, ...)
* TaskMessage -- format is {task: Task, error: Function}
* ArrayMessage == format is [LensMessage, ...], this is for performance
* replaceMessage -- any message isn't like the above two messages will be think of replace model for some special occasion like routing.

**Note**: For message, key and task is a reserved words.
npm package: @koy/cli
Description: A command line interface for building wonderful koy app.
Author: murakami
Latest version: 0.0.4

# @koy/cli

A command line interface for building wonderful koy app.

The current version(v0.0.3) is experimental.

## Usage

I just weite two simple and useful command -- list and create.

### list

You can use list for lokking up available templates currently.

```bash
koy list
```

### create

You may use it mostly for createing a new app.

```bash
koy create webpack my-app
```

### Help
You can -h or --help option for looking up some help message, like this:

```bash
koy -h
koy list -h
koy create -h
```
npm package: @koy/router
Description: A router for browser routing.
Author: murakami
Latest version: 0.1.12

# @koy/router

A router for browser routing.

I just define this library as simple as i can for that you can use some js packages you'd like.

## Link

I export a Link module that you can use it as HTML a tags.

for example: 

```js
const HomeLink = Link({href: '/home'}, 'Home')
```

## iBack, iForward, iGo, iReplace, iPush

All of them just the simple rewrite for corresponding history's function and wrapped it as IO(can cause onUrlChange in architecture's application).

for example:

```js
const HomeLinkP = Element.of(
  'p', {
    onclick: () => dispatch(ap(iPush, of(IO, '/home')))
  },
  Element.of('span', 'Home')
)
```
npm package: @koy/virtual-dom
Description: A virtual DOM algorithm.
Author: murakami
Latest version: 1.0.3

This is the official koy virtual dom library.

The library exports Element, diff and patch function that you can do some magical thing here.

### Element

Element is a Functor that you can do like React.createElement but I add more special functions.

> If you don't know about Functor, you'd better learn it and here is a good palce, [Tupperware](https://github.com/MostlyAdequate/mostly-adequate-guide/blob/master/ch08.md).

you can use Element.of when you want to create a dom object:

```js
Element.of('div', {class: 'container'}, 'murakami')
```

The above is the basic usage, If you are not familiar with Functor, I suggest you just treat Element as it.

And for some programmer, may know of is a function that put some thing into a container, that means I need some functions to handle it's value, this is map、join、chain and ap. There are the basic functions in function programming.

```js
const container = Element.of('div', {class: 'container'}, 'murakami')

map(({tagName, attributes, children}) => ['span', attributes, ...children], container) // equals to Element.of('span', {class: 'container'}, 'murakami')

const nestedContainer = Element.of(
  Element.of('div', {class: 'container'}, 'murakami')
)
join(nestedContainer) // equals to Element.of('div', {class: 'container'}, 'murakami')

chain(({tagName, attributes, children}) => Element.of(tagName, ...children), container) // equals to Element.of('div', 'murakami')

ap(Element.of(({tagName, attributes, children}) => ['span', attributes, ...children]), container) // equals to Element.of('span', {class: 'container'}, 'murakami')
```

This is some simple example, and If you are familiar with category theory, you may do some better things magically, I'm sorry, currently, I'm not good at it.

**Note: If your Element isn't an appropriate dom object, you can't render it in the user interface.**

### diff

The diff funciton is the implementation of diff algorithm, you can use it to diff two Element node tree, here is an example:

```js
diff(
  Element.of('div', {class: 'custom-container'}, Element.of('h2', 'Welcome to @koy/vitual-dom')),
  Element.of('div', {class: 'container'}, Element.of('h2', 'Welcome to koy'))
) // new Map([[0, [{type: 'ATTRIBUTES_CHANGE', attributes: {class: 'custom-container'}}]], [2, [{type: 'TEXT_REPLACE', text: 'Welcome to @koy/vitual-dom'}]]])
```

**Note: The above comment is just a tip, isn't a real output when you use diff since I use Symbol and other data structure.**

### patch

The patch method can put the patches we get from diff method to real dom.

**Node: Make sure you root dom node lastChild is your root Element.**

```js
const root = document.getElementById('app')
patch(new Map([[0, [{type: 'ATTRIBUTES_CHANGE', attributes: {class: 'container'}}]]]), root) // can change root lastChild's className to 'container'
```
**Note: The above patch function's first parameter is just a tip, isn't a real Map structure when you use patch since I use Symbol and other data structure.**

> I'm glad to hear from you.
npm package: @koy/vitual-dom
Description: A virtual DOM algorithm.
Author: murakami
Latest version: 0.16.4
Deprecated: The library is moved to [@koy/virtual-dom](https://www.npmjs.com/package/@koy/virtual-dom) because the wrong package name, how stupid do I. Go there to see more details.This library will not be maintained.

# @koy/core

A virtual DOM algorithm.

## Why I write this library?

Since vitual DOM is so popular and many library have realized it，and I write it's for that I want to buid an app with the most natural javascript funcitonal programming way, that means we should run some code on webWorker or some other parallel way. I should control my code and know what should put to there and what not, so It comes.

> It may not the best vitual DOM algorithm, it just a way that I realize.

## How do I design this library?

You means, What a virtual DOM algorithm contains? An Element, a diff logic and a patch method, so you got it here.

### Element

I design it as a class if you are familiar with OOP, but we shouldn't think it's a class and think it as a Container, or malformed Functor without map. And, you can use of method to put your dom type to Element like this:

```js
Element.of('div', {class: 'container'}, Element.of('h2', 'Welcome to koy'))
```

### diff

The diff method can diff two Element and get their differences:

```js
diff(
  Element.of('div', {class: 'custom-container'}, Element.of('h2', 'Welcome to @koy/vitual-dom')),
  Element.of('div', {class: 'container'}, Element.of('h2', 'Welcome to koy'))
) // [0: [type: 1, attributes: {class: 'custom-container'}], 2: [type: 0, text: 'Welcome to @koy/vitual-dom']]
```

### patch

The patch method can put the patches we get from diff method to real dom.

**Note**: make sure you root dom node lastChild is your root Element.

```js
const root = document.getElementById('app')
patch({0: [type: 1, attributes: {class: 'container'}]}, root) // can change root lastChild's className to container
```
npm package: @koyal-tech/editable-react-table
Description: Editable React table component
Author: koyaltech
Latest version: 0.1.2

## Editable React Table

[![Edit editable-react-table](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/editable-react-table-gchwp?fontsize=14&hidenavigation=1&theme=dark)

![editable-react-table](https://user-images.githubusercontent.com/30985772/118361385-dd7caa00-b5a8-11eb-808b-1b4075f4a09d.gif)

### Features

- Resizing columns
- Cell data types - number, text, select
- Renaming column headers
- Sort on individual columns
- Adding columns to left or right of a column
- Adding column to end
- Editing data in cells
- Adding a new row of data
- Deleting a column
- Changing column data types
- Adding options for cells of type select

### Getting Started

1. Clone this repository.

```bash
git clone https://github.com/archit-p/editable-react-table
```

2. Install dependencies and build.

```bash
npm install
npm start
```

### Contributions

Contributions are welcome! Feel free to pick an item from the roadmap below or open a fresh issue!

### Roadmap

- [x] Support for virtualized rows
- [ ] Date data-type
- [ ] Multi-Select data-type
- [ ] Checkbox data-type
- [ ] Animating dropdowns
- [ ] Performance - supporting 100000 rows
npm package: @koyeb/mcp-server
Description: > [!NOTE] > > **Koyeb MCP** is currently a beta pre-release. Feedback, bug reports, and contributions are welcome! Please open an issue or pull request. > > Planned features: > Secrets, volumes, domains, pause/resume, update app, cancel deployment, metric
Latest version: 1.0.9

# Koyeb MCP Server

> [!NOTE]
>
> **Koyeb MCP** is currently a beta pre-release. Feedback, bug reports, and contributions are welcome! Please open an issue or pull request.
>
> Planned features:
> Secrets, volumes, domains, pause/resume, update app, cancel deployment, metrics, log tailing

A [Model Context Protocol (MCP)](https://modelcontextprotocol.org) server implementation for the [Koyeb](https://www.koyeb.com) API. This project enables programmatic management of Koyeb resources (apps, services, deployments, instances, logs, and more) via the MCP protocol.

## Features

- **App Management**

  - List, get, and create Koyeb apps

- **Service Management**

  - List, get, create, and update services within apps

- **Deployment Management**

  - List and get deployments, query build/runtime logs

- **Instance Management**

  - List and get instances for deployments/services

- **One-Click Apps**
  - List available one-click (example) apps on Koyeb

## Adding MCP config to your client

Add the following to your `.cursor/mcp.json` or `claude_desktop_config.json`.

```json
{
  "mcpServers": {
    "koyebApi": {
      "command": "npx",
      "args": ["-y", "@koyeb/mcp-server"],
      "env": {
        "KOYEB_TOKEN": "your_token_here"
      }
    }
  }
}
```

## CLI usage

1. **Install the package from npmjs:**

```sh
npm install -g @koyeb/mcp-server
```

2. **Set your Koyeb API token:**

Create a token at [Koyeb API settings](https://app.koyeb.com/user/settings/api) and export it:

```sh
export KOYEB_TOKEN=your_token_here
```

3. **Start the MCP server:**

```sh
koyeb-mcp
```

The server will connect via stdio and expose the Koyeb API as MCP tools.

## License

MIT