open-index/open-npm huggingface dataset:
npm package: @pekings/r-ui-component
Description: React UI components library
Author: PEIQIN HONG
Latest version: 0.2.6

## react ui component library

### Install

Using `npm` to install

```bash
npm install @pekings/r-ui-component --save
```

Using `yarn` to install

```bash
yarn add @pekings/r-ui-component
```

### Quickstart

```js
// 全局引入样式
import "@pekings/r-ui-component/dist/index.css";
// 引入组件
import { Button } from "@pekings/r-ui-component";
```

## Links

- [Documentation](https://perryhong.github.io/r-ui-component)
npm package: @pekosog/node-mongo-seeds
Description: A tool to populate a mongo db from json files
Author: Tom Caflisch
Latest version: 3.1.3

# node-mongo-seeds
[![Build Status](https://travis-ci.org/toymachiner62/node-mongo-seeds.svg?branch=master)](https://travis-ci.org/toymachiner62/node-mongo-seeds)
[![Code Climate](https://codeclimate.com/github/toymachiner62/node-mongo-seeds/badges/gpa.svg)](https://codeclimate.com/github/toymachiner62/node-mongo-seeds)
[![Test Coverage](https://api.codeclimate.com/v1/badges/0c613fd309e01cd2a790/test_coverage)](https://codeclimate.com/github/toymachiner62/node-mongo-seeds/test_coverage)


> A tool to quickly populate your mongo db from a set of .json files. The concept is very similar to Ruby on Rails idea of seeding a database. This allows a new developer to pull down the source code for a project (which contains .json files to populate their mongodb with) and run a command and bingo!! database populated and ready to rock.

## Setup

```sh
$ npm install -g node-mongo-seeds
```

## Usage

### seed-setup
Generate the setup file `seed.js`.

- From the root of your project:

	```sh
	$ seed-setup
	```

- Replace `"localhost/LOCAL_DB_NAME"` with the path to your mongodb in your brand new `seed.js` file

- Create a `/seeds` folder in your project root and put `.json` files or `.js` files which **export a json object** in there.
		The name of the file is going to be the collection name in mongo and the contents
		of the file will be populated into that mongo collection.
	- Note that this package supports the [mongo-extended-json syntax](https://docs.mongodb.com/manual/reference/mongodb-extended-json/)

### seed
Seed your mongodb with all your data from your `/seeds` folder.

- From the root of your project:

	```sh
	$ seed
	``` 
	
	```sh
	$ seed --help
	
	Usage: seed [options]

  Options:

    -s, --seeds-folder [folder]  Use seeds folder [folder]
    -h, --help                   output usage information
	```

**Note**: Every time you run `$ seed` it will blow away all the data in your collections and re-populate them with whatever is in your `/seeds` directory.

### Separate databases per NODE_ENV

You can have separate databases for each NODE_ENV that you are using. Just a put a line in `seed.js` for each `NODE_ENV` that you are going to use. It defaults to `undefined`, `dev`, and `prod` but can be changed to whatever.

## Contributing

1. Clone project and run `npm install -g ./` from project root
2. Add feature(s)
3. Add tests for it
4. Submit pull request

### Running Tests

To run the tests, follow these instructions.

1. Start mongod process		
2. From project root `$ npm install`
3. Run test command `$ npm test`

Enjoy!
npm package: @pektin/client
Description: A client to facilitate the control of pektin dns servers
Author: Paul Colin Hennig
Latest version: 1.7.6

# JavaScript / TypeScript

[git.y.gy](https://git.y.gy/pektin/pektin-js-client) | [GitLab](https://gitlab.com/pektin/pektin-js-client) | [GitHub](https://github.com/pektin-dns/pektin-js-client) | [NPM](https://www.npmjs.com/package/@pektin/client)

## Install

```shell
yarn add @pektin/client
```

```shell
npm i @pektin/client
```

## Basic Use

**Normaly you should NEVER store your credentials in a code file but use something like a .env file. Have a look at [dotenv](https://www.npmjs.com/package/dotenv) for Node.js.**

```ts
import { PektinClient } from "@pektin/client";

const pc = new PektinClient({
    username: "ui-j-6samfz_r1OTQ",
    password:
        "Bq9Wvf4_FeDtKNoxdFLJweZzYhKVnN4Ll9SiQniyBRQIu2c_1BIHqGihFr6KlQproTrMndkSA50aUQY_HS8VRJNWBdveGAeoWWwcGrECPBwgIygDbKUjeXHaGE2FOvXeWTmbHg",
    vaultEndpoint: "https://vault-pektin.pektin.xyz",
});

console.log(await pc.getDomains());
```

-   "manager" that can create vault roles holds pw for "confidant"
-   "confidant" holds half of password for "signers"
-   "signer" can sign for domains

# яндекс.рф

TODO mark position in output when serde returns something like `at line 1 column 357`

pektin.club 3600 DNSKEY 257 3 ECDSAP256SHA256 8KGSgDJjmg2DafFiTtBjs7f/wUg158qtEsJ0EcwrN+bSZcP2cYfTaqkRTsDV3ArlUAKOJ19tLdVypoLXLZjHWQ==

ns1.pektin.club 3600 RRSIG AAAA ECDSAP256SHA256 2 60 20220509215921 20220504215921 35187 pektin.club mlkM/TEtj04JZbaW77Dw4nNiIkiHYm5Lcy/okLejb1jz1Qj4r4AnWYQCnSsutPmpq2xGR56cb7vY71q9GSS/+A==
npm package: @pektin/declare-fs
Description: Declare your wanted filesystem structure instead of manually creating folders and files. Create fs structures with nodejs deno or output a shell script that creates them!
Author: Paul Colin Hennig
Latest version: 2.2.2

# The Problem

## Tired of creating folders and files one by one like this?

```ts
const baseFolder = "base";
await fs.writeFile(path.join(baseFolder, `folder`, `file.txt`), "some string");
await fs.writeFile(path.join(baseFolder, `folder`), "some string");
```

## Losing track of the folders/files created?

## Missing subdirectories throwing nasty errors?

## Importing fs with or without promises...?

## Joining paths?

## Telling users to create folders/files for your project by hand like this?

1. `mkdir yourProject`
2. `git clone https://yourawesomeproject yourProject`
3. `cd yourProject`
4. `touch .env`
5. Now create a secret using your favorite password manager... if you have one
6. it has to look like this `SECRET_VAR_FOR_PROJECT="d903j89feoef"`
7. ohh this works different on another OS... bad luck

# `declare-fs` to the rescue

With `declare-fs` you won't have to imperatively tell what files and folders you want to have created.
You can just declare them like this:

```ts
import { declareFs } from "@pektin/declare-fs";

const options: = {
    replace: true, // delete ALL folders/files first
    method: `node` // method to use for creation; defaults to `sh-command`
};
declareFs({
    orange: {
        // empty folder named black
        black: {},
        // file with the name "hello-world.txt" and the contents "Hello World!"
        "hello-world.txt": "Hello World!",
        // have the quokka git repo cloned into the folder green
        green: { $git: `https://github.com/wallabyjs/quokka` },
        // a file like hello-wold.txt above but with the permission set to executable
        "run-my-app.sh": { $file: `echo "Hello World!"`, $perms: `700` },
    },
},options);
```

## Resulting filesystem structure

```sh
orange
├── black
├── green
│   ├── EULA.md
│   ├── ISSUE_TEMPLATE
│   └── README.md
├── hello-world.txt # Hello World!
└── run-my-app.sh # echo "Hello World!"
```

## Without options

```ts
import { declareFs } from "@pektin/declare-fs";

declareFs({
    orange: {
        // empty folder named black
        black: {},
        // file with the name "hello-world.txt" and the contents "Hello World!"
        "hello-world.txt": "Hello World!",
        // have the quokka git repo cloned into the folder green
        green: { $git: `https://github.com/wallabyjs/quokka` },
        // a file like hello-wold.txt above but with the permission set to executable
        "run-my-app.sh": { $file: `echo "Hello World!"`, $perms: `700` },
    },
});
```

This will return

`sh -c 'mkdir ./orange;mkdir ./orange/black;echo -e "Hello World!"> ./orange/hello-world.txt;git clone https://github.com/wallabyjs/quokka ./orange/green;echo -e "echo \"Hello World!\""> ./orange/run-my-app.sh;chmod 700 ./orange/run-my-app.sh'`

what will create the same structure as above when executed

# Different modes

-   deno
-   node
-   sh-script
-   sh-command

# No runtime dependencies
npm package: @pektin/global-registrar
Description: Easy access to multiple domain registrar APIs.
Author: Paul Colin Hennig
Latest version: 1.1.3

# Global Registrar

https://docs.google.com/spreadsheets/d/1zl5xMsISb8gbo3SSOZJ3QXzHEOdL7QnrmpfLgKHDl6U/edit?usp=sharing

# TODO enable no downtime dns update to pektin
npm package: @pektin/js-fs
Description: Declare your wanted filesystem structure instead of manually creating folders and files. Create fs structures with nodejs deno or output a shell script that creates them!
Author: Paul Colin Hennig
Latest version: 2.2.1

# The Problem

## Tired of creating folders and files one by one like this?

```ts
const baseFolder = "base";
await fs.writeFile(path.join(baseFolder, `folder`, `file.txt`), "some string");
await fs.writeFile(path.join(baseFolder, `folder`), "some string");
```

## Losing track of the folders/files created?

## Missing subdirectories throwing nasty errors?

## Importing fs with or without promises...?

## Joining paths?

## Telling users to create folders/files for your project by hand like this?

1. `mkdir yourProject`
2. `git clone https://yourawesomeproject yourProject`
3. `cd yourProject`
4. `touch .env`
5. Now create a secret using your favorite password manager... if you have one
6. it has to look like this `SECRET_VAR_FOR_PROJECT="d903j89feoef"`
7. ohh this works different on another OS... bad luck

# `declare-fs` to the rescue

With `declare-fs` you won't have to imperatively tell what files and folders you want to have created.
You can just declare them like this:

```ts
import { declareFs } from "@pektin/declare-fs";

const options: = {
    replace: true, // delete ALL folders/files first
    method: `node` // method to use for creation; defaults to `sh-command`
};
declareFs({
    orange: {
        // empty folder named black
        black: {},
        // file with the name "hello-world.txt" and the contents "Hello World!"
        "hello-world.txt": "Hello World!",
        // have the quokka git repo cloned into the folder green
        green: { $git: `https://github.com/wallabyjs/quokka` },
        // a file like hello-wold.txt above but with the permission set to executable
        "run-my-app.sh": { $file: `echo "Hello World!"`, $perms: `700` },
    },
},options);
```

## Resulting filesystem structure

```sh
orange
├── black
├── green
│   ├── EULA.md
│   ├── ISSUE_TEMPLATE
│   └── README.md
├── hello-world.txt # Hello World!
└── run-my-app.sh # echo "Hello World!"
```

## Without options

```ts
import { declareFs } from "@pektin/declare-fs";

declareFs({
    orange: {
        // empty folder named black
        black: {},
        // file with the name "hello-world.txt" and the contents "Hello World!"
        "hello-world.txt": "Hello World!",
        // have the quokka git repo cloned into the folder green
        green: { $git: `https://github.com/wallabyjs/quokka` },
        // a file like hello-wold.txt above but with the permission set to executable
        "run-my-app.sh": { $file: `echo "Hello World!"`, $perms: `700` },
    },
});
```

This will return

`sh -c 'mkdir ./orange;mkdir ./orange/black;echo -e "Hello World!"> ./orange/hello-world.txt;git clone https://github.com/wallabyjs/quokka ./orange/green;echo -e "echo \"Hello World!\""> ./orange/run-my-app.sh;chmod 700 ./orange/run-my-app.sh'`

what will create the same structure as above when executed

# Different modes

-   deno
-   node
-   sh-script
-   sh-command

# No runtime dependencies