open-index/open-npm huggingface dataset:
npm package: @kbase/base-css
Description: KBase CSS basics with Tachyons
Author: KBase Team
Latest version: 0.0.2

# KBase CSS

Based on [Tachyons](http://tachyons.io/), using the same classnames. Refer to its documentation for usage.

This video has a succinct explanation of how this repo was set up: https://vimeo.com/174698456

## Installation

> WIP

Using the unpkg cdn:

```
<link rel="stylesheet" href="https://unpkg.com/kbaseincubator/kbase-css@4.11.2/css/tachyons.min.css"/>
```

Or install via npm.

## Development

After cloning this repo:

```sh
npm i
npm start
```

In another terminal, start a development server:

```sh
npm run serve
```

To build the CSS for distribution, run `npm run build`.
npm package: @kbc-studios/utils.js
Description: A utility designed primarily to facilitate the development of discord bots.
Author: KingsBeCats
Latest version: 1.0.0

A utility designed primarily to facilitate the development of discord bots.

# Documentation
See the documentation on: [Utils Docs](https://kbcstudios.github.io/utils/)

# Instalation
```sh
npm i @kbc-studios/utils.js
```

# Quick Setup
```ts
import { Util } from "@kbc-studios/utils.js"

const util = new Util()

console.log(util.version)
```
npm package: @kbco/pcpartpicker
Description: An unofficial client for the 2019 PC part picker api
Author: Austin Kregel
Latest version: 0.0.2

# What is @kbco/pcpartpicker?
This is mean to be a super dynamic library for querying against the undocumented API that PC Part Picker has.

Right now only the following part types are supported: `cpu`, `cpu cooler`, `motherboard`, `memory`, `storage`, `video card`, `power supply`, and `case`.

To add support for more part types, all that will need to be done is updating the `constants.js` file to have the [proper mappings](#proper-mappings), and the actual api url.

## So how do I use it?
```
yarn add pc-part-picker
```
or
```
npm add --save pc-part-picker
```
then somewhere in you script

Using async/await
```js
const partPicker = require('@kbco/pcpartpicker');

let queryPartPicker = async (type) => await partPicker.query(partPicker.constants.urls[type], partPicker.constants[type])
  
let searchPartPicker = async (type, query) => await partPicker.search(type, query)

console.log(searchPartPicker('cpu', 'Ryzen'))
```
Using promises

```js
const partPicker = require('@kbco/pcpartpicker');

function queryPartPicker (type) { 
    return partPicker.query(partPicker.constants.urls[type], partPicker.constants[type])
}

function searchPartPicker(type, query) {
    return partPicker.search(type, query)
}

searchPartPicker('cpu', 'Ryzen')
    .then(function (parts) {
        console.log(parts)
    })
```

## Support on Beerpay
Hey dude! Help me out for a couple of :beers:!

[![Beerpay](https://beerpay.io/austinkregel/pc-part-picker/badge.svg?style=beer-square)](https://beerpay.io/austinkregel/pc-part-picker)  [![Beerpay](https://beerpay.io/austinkregel/pc-part-picker/make-wish.svg?style=flat-square)](https://beerpay.io/austinkregel/pc-part-picker?focus=wish)

# Proper Mappings
So this is a little bit tricky. I'll do my best to explain.

### Finding the API endpoint.
 - Open the developer tools for your browser.
 - Go to the page you want to add support for. 
 - Go to the network tab.
 - Look for the request that looks like `?mode=list&xslug=&search=`
 - Copy that full URL and paste it into your local constants file.
 - Go back to the page and we're going to want to count the number of columns that it has, starting at `0` (zero)
   - Note that for each column, we may want to normalize the fields (like for the video card's page the column of index `1` is called "Video Card", we call it "name" since it's the name of the part).
 - Once you have the indices and the column names, you're going to want to put them in the `constants.js` file, associated with the proper key (You'll have to creat a new one...).
npm package: @kbco/player
Description: A easy player for streaming video
Author: austinkregel
Latest version: 0.0.9

# What is @kbco/player?

Well it's a way to simply serve and play videos from your computer.

## Why?
Because I'm lazy... I have a chromebook... and I wanted videos to autoplay... 

## How to use?

Install it to your computer with...
```
npm install -g @kbco/player
```
Once installed

```
kbco-player start <dir_name> <port>
```

The directory name is required, and the port is not required. The directory name is the directory it's searching through to gather the videos.

The port is optional, but defaults to 3000. This is the port you access the program from.
npm package: @kbco/provider
Description: A simple way to register plugins for your projects
Author: Austin Kregel
Latest version: 0.1.1

# What is @kbco/provider?

Well it's a way to simply define plugins for your package, and register them in a special order.

## How to use?
```js
const Registration = require('@kbco/provider');

const Provider = new Registration();

// Provider will register every service in the order you list them in.
Provider.register({
    'TestProvider': './tests/TestProvider',
    'terminal': '@re-base/termianl',
    'customProvider': {
        register() {
        
        }
    }
})
```

The following is an example service provider which would register two routes with express.
```js
// AuthServiceProvider.js

const express = require('express')

const app = express()

const router = require('@kbco/router')(app);

module.exports = {
    register() {
        router.get('/register', (req, res) => ('Register an account!!'))
        router.get('/login', (req, res) => ('Log into your account!!'))
        // Returning an object binds the objects to the registered service making
        // them more globally accessable.
        return router
    }
}
```

With Provider, you can register packages that export a register method on an object, or you can register personal packages, or even new classes with just a register method. 

I tried to keep it simple, amd easy to use. If you have suggestions for how we can improve the way this works, make a PR or you can make an issue. :smile:
npm package: @kbco/query-builder
Description: A way to convert objects, and arrays into a query string for a url
Author: Austin Kregel
Latest version: 0.0.4

<p align="center">

![npm](https://img.shields.io/npm/dm/@kbco/query-builder.svg)
![NPM](https://img.shields.io/npm/l/@kbco/query-builder.svg)
![npm](https://img.shields.io/npm/v/@kbco/query-builder.svg)
</p>

## node-http-query-builder
I just wanted an easy way to convert objects into query strings. I was tired of not having a decent option...

### Installation
```bash
npm install --save @kbco/query-builder
```
```bash
yarn add @kbco/query-builder
```

### Usage
```js
const { buildUrl } = require('@kbco/query-builder')

let url = buildUrl('/your-route-to-build-a-query-for', {
    option: 'do build something for',
    objectThing: {
        'a key-value pair': 'of values'
    },
    arrayThing: ['array', 'of', 'values'],
})

// The url value would be '/your-route-to-build-a-query-for?option=do%20build%20something%20for&objectThing[a%20key-value%20pair]=of%20valuesarrayThing=array,of,values'
// then use your favorite ajax lib to make a call against that URL. (For me I like axios)
axios.get(url)
    .then(({ data })=> {
        // do something with the returned data.
    })
```
npm package: @kbco/router
Description: A simple router wrapper for express
Author: Austin Kregel
Latest version: 0.3.4

# What is @kbco/router?

Well it's a way to simply define routes, and return the result.

## Why?
Honestly, it's because I'm a PHP (Laravel) developer trying to make the switch to Node, and there are things I miss like being able to return from my controllers or routes and not have to worry about typing `res.send`.

## How to use?
A very simple example (modified from [express's hello world example](http://expressjs.com/en/starter/hello-world.html)).
```node
const express = require('express')

const app = express()

const router = require('@kbco/router')(app);

router.get('/', (req, res) => ('Hello World!'))

app.listen(3000, () => console.log('Example app listening on port 3000!'))
```
Using older syntax you can accomplish the same as the above with:

```node
var express = require('express')

var app = express()

var router = require('@kbco/router')(app);

router.get('/', function(req, res) {
    return 'Hello World!';
});

app.listen(3000, function() {
    console.log('Example app listening on port 3000!');
}):
```

This package will automatically convert returned objects to json and set the approprate headers for a json response. Every closure from the router will get the request and response objects from express.

### What about resources?
If you wish to declare a more "RESTful" resource use

```node
router.resource('resource_name', {
    index() {},
    store() {},
    update() {},
    destroy() {},
    show() {}
})
```
It will automatically declare the corresponding get/post/put/delete/get requests so you can type a little less and get the same functionallity as every other route.

# Other frameworks
I made sure to test with other frameworks and wanted to be able to have a more fluent interface across the board. If you're looking to use a framework that isn't offically supported, or needs custom configuration, then you're welcome to submit a PR.

### Tested frameworks 
 - [Hapi](https://github.com/hapijs/hapi)
```node
const Hapi = require('hapi');
const server = new Hapi.Server();

server.connection({ port: 3000, host: 'localhost' });

const router = require('@kbco/router')(null, function (method, path, handler) {
    return server.route({
        method,
        path,
        handler: function (response, reply) {
            return reply(handler(response, reply));
        });
    });
});

router.get('/', function(req, res) {
    return 'Hello World!';
});

server.start((err) => console.log(err || `Server running at: ${server.info.uri}`));

```
 - [Express](https://github.com/expressjs/express)
See the "How to use" section.

## Support on Beerpay
Hey dude! Help me out for a couple of :beers:!

[![Beerpay](https://beerpay.io/metabitco/router-wrapper/badge.svg?style=beer-square)](https://beerpay.io/metabitco/router-wrapper)  [![Beerpay](https://beerpay.io/metabitco/router-wrapper/make-wish.svg?style=flat-square)](https://beerpay.io/metabitco/router-wrapper?focus=wish)
npm package: @kbco/system-process
Description: A little library to give you programatic access to get information about system processes.
Author: Austin Kregel
Latest version: 0.0.2

# System Processes
A little library to give you programatic access to get information about system processes..

### How to use
 2 ways to use. If (for whatever reason) you're using [Fringe](https://github.com/austinkregel/fringejs), you should be able to require the file via `require('@kbco/system-process/fringe')`
 
Or if you want to use it at your own leasure (recommended)

```
const SystemProcesses = require('@kbco/system-process');

console.log(await SystemProcesses.getServices());
```