open-index/open-npm huggingface dataset:
npm package: @keg-hub/args-parse
Description: Parse command line arguments
Author: keg-hub
Latest version: 10.0.1

# argsParse
Parse command line arguments

## Setup

### Install It

* With **yarn**
```bash
yarn add @keg-hub/args-parse
```

* With **npm**
```bash
npm install @keg-hub/args-parse
```

### Use It
See test [examples](https://github.com/keg-hub/keg-cli/blob/main/repos/args-parse/src/__tests__/argsParse.js)

```js
;(() => {

  const { argsParse } = require('@keg-hub/args-parse')
  const task = {
    options: {
      // Define required
      doo: {
        description: "dew the doo",
        require: true,
      },
      // Define defaults
      foo: {
        description: 'I am foo bar',
        default: 'bar'
      },
      baz: {
      // Define alias
        alias: [ 'zoo' ],
        description: 'The baz with bas',
      },
    }
  }
  
  const parsed = await argsParse({
    task,
    args: [ 'doo=f', '--zoo', 'bas', ],
  })
  
  expect(parsed.doo).toBe(false)
  expect(parsed.foo).toBe('bar')
  expect(parsed.baz).toBe('bas')

})()

```

## Custom Config
* Use the `PARSE_CONFIG_PATH` environment vairable to overwrite the path to the parse config
  * Path should be relative to the applications root directory
* See default [config](https://github.com/keg-hub/keg-cli/blob/main/repos/args-parse/configs/parse.config.js)
* Custom Configs should match the keys within the default config
  * `bools` && `environment`
npm package: @keg-hub/ask-it
Description: Node CLI helper for asking questions
Author: Lance Tipton
Latest version: 1.1.2

# AskIt
Wrapper around [inquirer](https://www.npmjs.com/package/inquirer) to make asking questions in Node CLIs easier.

## Setup

### Install It
Add to your package.json

  ```js
    "askIt": "git+https://github.com/keg-hub/askIt.git"
  ```

### Use It
See an [example here](https://github.com/keg-hub/askIt/blob/master/scripts/validate.js)

```js
;(() => {

  const { ask, separator, models } = require('askIt')

  // See src/models/models for more information
  const questionModelObject = {
    // Add the default input model
    ...models.input,
    // Override with custom values
    type: 'Question type',
    name: 'Name of the question',
    message: 'Question to ask',
    default: 'Default value if user enters nothing',
  }

  // Pass the model directly to the ask method
  // Returns a value entered by the user or the default
  const askResponse = await ask({ ...questionModelObject })

  // Ask a true / false question
  // Returns a boolean
  const confirmResponse = await ask.confirm('Ask a confirm question?')

  // Ask for text input
  // Returns a string of the entered text
  const inputResponse = await ask.input('Ask for text input')
  
  // Ask for a password / secret - input will be hidden
  // Returns a string of the entered text
  const passwordResponse = await ask.password('Ask for hidden text input')

  // Ask for user to select an option from a list of options
  // Returns the index of the select option within the passed in array
  const listResponse = await ask.promptList([
    'Option 1',
    'Option 2',
    'Option 3',
  ])

})()

```

## API

### ask
  * *@type* `function`
  * *@param*  `Object` - a question model object
    * See [src/models/models.js](https://github.com/keg-hub/askIt/blob/master/src/models/models.js)
  * **ask.confirm**
    * *@type* `function`
    * *@param*  `string` - The true / false question to ask
    * Helper method to ask a true/false question
    * Accepts a `string` used as the question asked to the user
  * **ask.input**
    * *@type* `function`
    * *@param*  `string` - The text input question to ask
    * Helper method to ask a text input question
  * **ask.password**
    * *@type* `function`
    * *@param*  `string` - The text input question to ask
    * Same as `ask.input`, except user input is hidden
  * **ask.promptList**
    * *@type* `function`
    * *@param*  `array` - List of options to present to the user
    * Asks the user to select from a list of options
    * @returns - `index` of the selected item from the passed in `options`
****
### separator
  * *@type* `function`
  * Helper that returns `new inquirer.Separator()`

### models
  * *@type* `Object`
  * Prebuilt question models with defaults already set
  * Expected to be overwritten with custom values as needed
  * **Question model object**
    * Matches the [inquirer questions](https://github.com/SBoudrias/Inquirer.js#questions) model
npm package: @keg-hub/docker-lib
Description: Wrapper around the git command line executable
Author: Lance Tipton
Latest version: 0.0.2

# Docker-Lib
Wrapper around the docker command line executable

### Install
With **yarn**
```bash
yarn add @keg-hub/docker-lib
```
With **npm**
```bash
npm install @keg-hub/docker-lib
```

## Setup
* Requires docker executable to be installed, and in the `$PATH`

## Example
```js
// Add the docker lib to your script
const { docker } = require('@keg-hub/docker-lib')

// Execute a command on a docker container...
await docker.container.exec({
  ...args
})

// Create a new image from the container
await docker.container.commit({
  ...args
})

// Tag a new image docker image
await docker.image.tag({
  ...args
})

// Push the new image to a remote repository...
await docker.push({
  ...args
})
```

## API
### TODO
npm package: @keg-hub/git-lib
Description: Wrapper around the git command line executable
Author: Lance Tipton
Latest version: 0.1.1

# Git-Lib
Wrapper around the git command line executable

### Install
With **yarn**
```bash
yarn add @keg-hub/git-lib
```
With **npm**
```bash
npm install @keg-hub/git-lib
```

## Setup
* Requires git to be installed, and on the `$PATH`


## Example
```js
// Beginning of your code
const { git } = require('@keg-hub/git-lib')

// ...Modify some files, save them, then...

// Add the changed files...
await git.add({
  files: [ '.' ],
  // Optional, uses process.cwd() when not passed
  root: `path/to/git/directory`,
})

// Commit the changed files...
await git.commit({
  message: `Changed some files`,
  // Optional, uses process.cwd() when not passed
  root: `path/to/git/directory`,
})

// Push the changed files...
await git.push({
  // Optional, uses the current working branch
  branch: `remote-branch-name`,
  // Optional, default is origin
  remote: 'upstream',
  // Optional, uses process.cwd() when not passed
  root: `path/to/git/directory`,
})
```

## API
### TODO
npm package: @keg-hub/jsutils
Description: Keg common javascript utils
Author: lancetipton
Latest version: 10.0.0

# @keg-hub/jsutils
A utility library for commonly used helper methods. Similar to lodash, underscore, etc...
See docs at [https://keg-hub.github.io/jsutils](https://keg-hub.github.io/jsutils/)

## Add to your project
```js
  yarn add @keg-hub/jsutils
  npm install @keg-hub/jsutils
```

## Usage
```js
  // * Import the whole lib
  import { capitalize } from '@keg-hub/jsutils'

  // Or only the methods you need
  import { capitalize } from '@keg-hub/jsutils/capitalize'

  // * Or require code
  const { capitalize } = require('@keg-hub/jsutils')
  const { capitalize } = require('@keg-hub/jsutils/capitalize')

```
npm package: @keg-hub/keg-core
Description: A framework for developing cross-platform react apps, that is preconfigured to target both web, desktop, and mobile architectures.
Latest version: 10.1.0

# Keg Core

## Overview

The keg is a platform for developing cross-platform react apps.
It comes preconfigured to target both web and mobile, and it contains a 
collection of utilities for simplifying development, including:
  * built-in routing and navigation
  * a reducer based on the relational data model
  * dynamic theming via [re-theme](https://github.com/keg-hub/re-theme)
  * cross platform persistent storage

## Tap usage

* To start, first setup the [keg-cli](https://github.com/keg-hub/keg-cli#install)
* Next, use the cli to generate a tap:
`keg gn tap`
* `cd` into your tap's directory, then run `yarn setup`
* The tap you generated will have installed `keg-core` as a dependency
* Read more about tap-development [here](https://www.some-docs-we-need-to-write.confluence.com)

### Defining Environment Variables
* Within your tap's config file (e.g. `tap.js`, `tap.json`), you can define an `envs` property in the `keg` object like this:
```js
module.exports = {
  ...,
  keg: {
    ...
    envs: {
      'process.env.FOO': 'bar',
      SOME_API_KEY: getAPIKey()
      'process.env.TAP_LICENSE': 'tap.package.license'
    }
  }
}
```
And these will be replaced in your code, so that you can use them like this:
```js
const myFunction () {
  makeAPICall(SOME_API_KEY)
  console.log('Foo', process.env.FOO)
  console.log('This tap uses the license', process.env.TAP_LICENSE)
}
```
  * you can define dynamic envs that pull data from a `package.json` or an app config by using the form:
    `<tap|core>.<package|config>.<some_property>`
    * so the `tap.package.license` will evaluate to the value of the `license` property in your tap's `package.json`
  * every env is automatically stringified
#### Running with webpack / expo
  * These envs are automatically replaced for you at build time
#### Running with other build tools
  * If you use a different bundler, like rollup, you can still use these envs by importing
  the `getKegEnvs` function from `keg-core/core/scripts/js/getKegEnvs`
    * learn more [here](./core/scripts/js/getKegEnvs.js)
  * then, just use them into your tool's replacement plugin 

## Architecture

### Store

* [Reducers](core/base/reducers/README.md)
* [Plugins](core/base/store/plugins/README.md)
npm package: @keg-hub/mobile-tasks
Description: Keg-Cli tasks for developing mobile apps on the keg platform
Author: Lance Tipton
Latest version: 0.1.0

# Keg-Mobile-Tasks
* Is an export all tasks used within `tap-snack` which can be used by other taps as needed
* These are custom tasks used by the keg-cli.
  * They can also be executed by running `yarn task <task-name> <options>`

## Setup
* TODO
npm package: @keg-hub/re-theme
Description: Simple Theme switcher / builder for React and React Native
Author: Lance Tipton
Latest version: 10.1.0

# ReTheme
Tools for styling React or React Native components

## Setup
1. Add to your package.json

  ```js
    "re-theme": "git+https://github.com/keg-hub/re-theme"
  ```

2. Wrap the entry point of your application with an instance of `ReThemeProvider`, e.g.:
```js
import { ReThemeProvider } from 're-theme'

const myCustomTheme = { 
  // theme styles go here 
}

export const App from Component {
  state = { theme: myCustomTheme }

  componentDidUpdate = () => {
    this.props.theme !== this.state.theme &&
      this.setState({ theme: this.props.theme })
  }

  render(){
    return  (
      <ReThemeProvider theme={this.state.theme} merge={false}>
        <App />
      </ReThemeProvider>
    )
  }
}
```
  * `ReThemeProvider` accepts two props
    * `theme`: the theme object, containing any global styles you want to use across your app
    * `merge`: a boolean indicating whether or not you want to merge the passed in theme prop with the current theme

## reStyle
* `reStyle` is the preferred utility in ReTheme for styling your components

### Usage
```js
  ...
  import { reStyle } from '@keg-hub/re-theme/reStyle'

  // basic styling with an object
  const StyledButton = reStyle(Button)({
    position: 'absolute'
  })

  // using global theme
  const StyledButton = reStyle(Button)(theme => ({
    // reStyle also supports style aliases. View these aliases in src/constants/ruleHelpers.js
    pos: 'absolute',
    c: theme.colors.red
  }))

  // using theme and props
  const StyledButton = reStyle(Button)((theme, props) => ({
    position: 'absolute',
    color: theme.colors.red
    borderColor: props.outline || theme.colors.borderColor
  })

  // for styling components with any props, set the default props
  const StyledIcon = reStyle(SomeSvgIcon)(
    { position: 'absolute' }
    theme => ({
      // these are default props passed to `SomeSvgIcon`, not style attributes
      width: 32,
      height: 32
      className: 'some-class',
      customProp: theme.customValue
    })
  )

  /**
   * For specifying a specific prop for styles, pass in a string for the 2nd argument.
   * This is equivalent to: 
   *  const styles = {
   *    main: { position: 'absolute' },
   *    content: { margin: 32 }
   *  }
   *  <Container styles={styles}>
   */
  const StyledContainer = reStyle(Container, 'styles')({
    main: {
      position: 'absolute'
    },
    content: {
      margin: 32
    }
  })
```


### API
Checkout the [Example App](https://keg-hub.github.io/re-theme/) for documentation.
npm package: @keg-hub/rga4
Description: React Components and hooks for integrating Google Analytics 4 into an application
Author: lancetipton
Latest version: 0.0.4

# RGA4
React context and hooks for integrating Google Analytics 4 into an application

### Add / Install

```js
  yarn add @keg-hub/rga4
  npm install @keg-hub/rga4
```

## Setup

**Important**
* A Google Analytic 4 Measurement ID is required
* See this [page for more information](https://support.google.com/analytics/answer/9306384?visit_id=637436678402332999-753716772&rd=1)


## Example

  ```javascript
    import React, { useEffect, useCallback } from 'react'
    import { RGA4Provider, useRGA4 } from '@keg-hub/rga4'

    const Child = (props) => {

      // Use the hook to get access to the Google Analytics Context
      const rga4 = useRGA4()
      
      useEffect(() => {
        // Call the rga4.event method to send an analytics event
        rga4.event('page_view', {
          label: 'Github Readme',
          category: 'engagement',
        })
      }, [])

      // Custom analytics event when a button is clicked
      const onClick = useCallback(() => {
        // Call the rga4.event method to send an analytics event
        rga4.event('button_click', {
          event_label: 'Demo Button',
          event_category: 'engagement',
        })
      }, [ rga4 ])

      return (
        <div>
          <button onClick={onClick}>
            Demo Analytics Event
          </button>
        </div>
      )
    }

    export const Component = (props) => {
      const measurementID = `Replace with your GA4 Measurement ID`
      
      return (
        <RGA4Provider
          code={measurementID}
          config={{ ...Optional gtag config object }}
          gaCodes={[ ...Optional extra analytics IDs ]}
        >
          <Child />
        </RGA4Provider>
      )
    }
  ```
npm package: @keg-hub/spawn-cmd
Description: Cross platform child_process execution in Node
Author: Lance Tipton
Latest version: 0.3.2

### Spawn-CMD
  * Cross-Platform child_process library for Node

### Dependencies
* [app-root-path](https://github.com/inxilpro/node-app-root-path)
* [@keg-hub/jsutils](https://github.com/keg-hub/@keg-hub/jsutils)
* [tree-kill](https://github.com/pkrumins/node-tree-kill)
* [cross-spawn](https://github.com/moxystudio/node-cross-spawn)
* [shell-exec](https://github.com/tiaanduplessis/shell-exec)

## Install

  * Install with 'yarn' or 'npm'
    ```js
      // With Yarn
      yarn add @keg-hub/spawn-cmd
      // With NPM
      npm install @keg-hub/spawn-cmd
    ```
  * Add to your code
    ```js

      // * Require code
      const { spawnCmd } = require('@keg-hub/spawn-cmd')

      // Spawns a new terminal session and runs `ls -la` inside of it
      await spawnCmd('ls -la')

      // Pass in a config object as the second argument
      // See more information about the config in the config section
      const config = { args: [ '-la' ] cwd: __dirname }
      await spawnCmd('ls', config)

      // Pass in a directory to run the command from as the third argument
      const config = { args: [ '-la' ] cwd: __dirname }
      await spawnCmd('ls', config, path.join(__dirname, '../'))

    ```

### Config Object
  * args <Array> - Arguments to pass to the spawned command
  * cwd - Directory to run the command from
    * This can be overwirtten by passing the cwd as a third argument
  * onExit <Function> - Called when the process exits
  * onStdErr <Function> - Called on stderr output
  * onError <Function> - Called on an error other then stderr
  * onStdOut <Function> - Called on stdout
  * options <Object> - Settings to pass to the spawned process
    * Is joined with the default settings below
      ```js
        defaultSettings = {
          gid: process.getgid(),
          uid: process.getuid(),
          env: process.env,
          cwd: rootDir, // Project root directory, NOT spawn-cmd directory
          stdio: 'inherit',
        }
      ```

### Extra Command
 **asyncCmd**
  * Extra command that wraps around nodes `child_process.exec`
  * Makes it a promise wrapped in a try/catch
  * Also adds the commands exit code
  * Promise resolves consistently
  * Example => 
      ```js
        const { asyncCmd } = require('@keg-hub/spawn-cmd')
        
        ;(()=>{

          const { error, data, exitCode } = await asyncCmd('echo test')

          // String output of stderr
          console.log(error)

          // String output of stdout
          console.log(data)

          // Numbered exit code from the command
          // 0 === success, anything else is exit from error
          console.log(exitCode)

        })()
        

      ```
npm package: @kegi/react-library-template
Description: React library template
Author: Kevin Gilbert
Latest version: 0.0.4

<h1 align="center">Library name</h1>
<p align="center">A small description with <strong>some</strong> cute <strong>keywords</strong><p>

<div align="center">
  <img alt="Made with Typescript" style="margin:3px"
  src="https://img.shields.io/badge/Made%20with-Typescript-2f74c0?style=for-the-badge&logo=typescript&labelColor=#333" />
  <img alt="Made for React 16+" style="margin:3px"
  src="https://img.shields.io/badge/Made%20for-React%2016+-5ed3f3?style=for-the-badge&logo=react&labelColor=#333" />
</div>

<div align="center">
  <a href="https://ci.appveyor.com/project/kegi/react-library-template/history">
    <img alt="test coverage" style="margin:3px"
    src="https://img.shields.io/appveyor/build/kegi/react-library-template?style=flat-square" />
  </a>
  <a href="https://coveralls.io/github/kegi/react-library-template">
    <img alt="test coverage" style="margin:3px"
    src="https://img.shields.io/coveralls/github/kegi/react-library-template?style=flat-square" />
  </a>
  <a href="https://bundlephobia.com/package/@kegi/react-library-template">
    <img alt="bundle size" style="margin:3px" 
    src="https://img.shields.io/bundlephobia/min/@kegi/react-library-template?label=size&style=flat-square" />
  </a>
  <a href="https://www.npmjs.com/package/@kegi/react-library-template">
    <img alt="bundle size" style="margin:3px" 
    src="https://img.shields.io/npm/l/@kegi/react-library-template?color=%23007ec6&style=flat-square" />
  </a>
</div>

---

## React library template
This is a boilerplate to create a React library. This includes :

 - Tree shakeable build (ESM)
 - A working demo with hot module reloading
 - Supports TypeScript and handle declarations
 - Built on top of React CRA, compile with tsc
 - Deploy the demo on GH Pages (https://kegi.github.io/react-library-template/)
 - Storybook + Chromatic (https://616f4d6a953f04003a6f3fac-pofrmbwvjs.chromatic.com/)
 - Publish dist directory as root.
   - ```import { Foo, Bar } from 'library'```
   - ```import Foo from 'library/Foo'```
npm package: @kego/m9-k1-ui
Description: a vue module of miku-mirai ui corresponded to m9-k1-react version
Author: 傲雪凌寒小七罪
Latest version: 0.0.8

# M9-K1

<nobr>
![vue3.x](https://img.shields.io/badge/vue3.x-purple)
</nobr>
<nobr>
![typescript](https://img.shields.io/badge/typescript-red)
</nobr>
<nobr>
![scss](https://img.shields.io/badge/scss-yellow)
</nobr>
<nobr>
![K1-UI](https://img.shields.io/badge/K1-UI-green)
</nobr>
<nobr>
![vitepress](https://img.shields.io/badge/vitepress-orange)
</nobr>

##

The PC UI Components built on Vue3.x!

Vue3.x 打造的基础通用组件，vitepress搭建文档站点

## Docs Site

 - [m9-k1 ui](https://k1-dog.github.io/components/k1-boot.html)

## Usage

Install m9-k1-ui with npm

```bash
  npm install @kego/m9-k1-ui
```
main.js 加载注册组件
```bash
    import { createApp } from 'vue'
    import AppUI from './App.tsx'
    // !  <<< - use - miku-global-scss
    import '@kego/m9-k1-ui/style.css'
    // !  - use - miku-global-scss >>>
    // !  <<< - use - m9-k1-vue
    import m9 from '@kego/m9-k1-ui/m9-k1-vue.es.ts'
    // !  - use - m9-k1-vue >>>

    console.log(m9)

    const app = createApp(AppUI).use(m9.m9Install)

    app.mount('#app')

```
    
## Themes

支持明暗模式双色主题（推荐暗黑模式）

## Features
    1.  单实例 - dragHelper提示线
    2.  性能优化 - 虚拟滚动、防抖节流
    3.  高度集成 - 表单校验能力
    4.  部分可视化图表 - 柱状图、饼状图
    5.  TS - 类型校验

## 风格参考
    m9-k1 UI库的启蒙组件库 - PrimeVue（国外）
npm package: @kegovc/schema2joi
Description: **A layer between Joi and your implementation in order to have a dynamic validation schema** ## Installation
Author: KEGOVC
Latest version: 1.0.7

# @kegovc/schema2joi

**A layer between Joi and your implementation in order to have a dynamic validation schema**
## Installation

```sh
npm install schema2joi
```
#####or

```sh
yarn add schema2joi
```

### Example

**schema2joi** allows you to describe your data using a simple language based on json schemas, to pass it to a schema-joi. **schema2joi** uses all the benefits of the **joi** object using the waterfall paradigm.

#### Example

```js
const schema2joi = require('@kegovc/schema2joi')

const schema = schema2joi({
    username:{
        type: 'alphanum',
        min: 3,
        max: 30,
        required: true,
    },
    password:{
        type: 'string',
        pattern: /^[a-zA-Z0-9]{3,30}$/
    }
    repeat_password: {
        ref: 'password'
    }
    access_token: [
        {
            type: 'string'
        },
        {
            type: 'number'
        },
    ],
    birth_year:{
        type: 'number',
        format: 'integer',
        min: 1900,
        max: 2013,
    },
    email: {
        type: 'string',
        format: {
            fun:'email',
            param:{ 
                minDomainSegments: 2, 
                tlds: { 
                    allow: ['com', 'net'] 
                } 
            }
        },
    },
    extras: {
        type: 'object',
        properties: {
            val: {
                type: 'string'
            },
            val2: {
                type: 'number',
                required: true,
            }
        }
    }
    
}) 
    .with('username', 'birth_year')
    .xor('password', 'access_token')
    .with('password', 'repeat_password');


const val1 = schema.validate({ username: 'abc', birth_year: 1994 });
console.log(val1.error)
// -> { value: { username: 'abc', birth_year: 1994 } }

const val2 = schema.validate({});
console.log(val2.error)
// -> { value: {}, error: '"username" is required' }

// Also -

try {
    const valueAsync = await schema.validateAsync({ 
        username: 'abc', 
        birth_year: 1994 
    });
}
catch (err) {
    console.log('errorAsync', err)
 }
```


#### The most powerful schema description language and data validator for JavaScript

## [JOI](https://github.com/sideway/joi)

#### The most powerful schema description language and data validator for JavaScript.

### Visit the [hapi.dev](https://hapi.dev) Developer Portal for tutorials, documentation, and support

## Useful resources

- [Documentation and API](https://github.com/sideway/joi/blob/master/API.md)
- [Versions status](https://hapi.dev/resources/status/#joi)
- [Changelog](https://hapi.dev/family/joi/changelog/)
- [Project policies](https://hapi.dev/policies/)
- [Free and commercial support options](https://hapi.dev/support/)
npm package: @kehers/passport-slack
Description: Slack OAuth v2 authentication strategy for Passport
Author: Opeyemi Obembe
Latest version: 0.2.1

# @kehers/passport-slack

[Passport](http://passportjs.org/) strategy for authenticating with the Slack [OAuth v2](https://api.slack.com/authentication/oauth-v2) API. This lets you use the v2 OAuth endpoints, set granular scopes (both `user_scope` and `scope`) and get user profile.

## Install

```
$ npm install --save passport @kehers/passport-slack
```

## Usage

### Create a Slack App

Create a [Slack App](https://api.slack.com/slack-apps) to get a ****Client ID**** and ****Client Secret****. Ensure you selected the right bot and user scopes for your app’s needs. The Strategy uses `https://slack.com/api/users.identity` to retrieve user’s profile by default and this requires the `identity:basic` user scope. 

### Configure Strategy

Supply your Slack Client ID and Client Secret as options to the strategy. The strategy also requires a `verify` callback, which receives an access
token from the grant, data response from Slack and user profile. The `verify` callback must call `done` providing the value you
want to assign to `req.user` in authenticated requests.

```javascript
passport.use(new SlackStrategy({
  clientID: process.env.SLACK_CLIENT_ID,
  clientSecret: process.env.SLACK_CLIENT_SECRET,
  callbackURL: process.env.SLACK_CALLBACK
}, (accessToken, response, profile, done) => {
  // Create your desired user model and then call `done()`
  User.findOrCreate({ user_id: profile.user.id }, function (err, user) {
    return done(err, user)
  })
}))
```

### Authenticate Requests

Use `passport.authenticate()`, specifying the ‘slack’ strategy, to authenticate requests.

For example, as route middleware in an Express application:

```javascript
// Visiting this route when not already authenticated with slack will redirect the user to slack.com
// and ask the user to authorize your application
app.get('/auth', passport.authenticate('slack'))

// The user returns to the your site after the authorization above, and if it was successful
// the next route handler runs, otherwise the user is redirected to chosen failureRedirect.
app.get('/auth/callback',
  passport.authenticate('slack', { failureRedirect: '/login' }),
  function(req, res) {
    // Successful authentication, redirect home.
    res.redirect('/')
  });
```

You can pass in necessary `scope` and `user_scopes` depending on permissions required by your application.

```javascript
app.get('/auth', passport.authenticate('slack', {
  user_scope: ['users:read'],
  scope: ['team:read', 'chat:write', 'chat:write.customize', 'chat:write.public', 'commands', 'channels:read', 'im:history']
}))
```

## Examples

See the [`example` directory](example) for a simple implementation.

## Plug

Looking for a shared inbox and helpdesk built on Slack? See [sharedbox.app](https://sharedbox.app/?ref=gh)
npm package: @kehillahglobal/ui
Description: Contains all react components used on all Kehillah Gold Project Platforms
Author: Kehillah Development Team
Latest version: 1.0.42

# @kehillahglobal/ui

The repository holds well documented react components that are used to build all the Kehillah platforms.

### Contributors

- Frimpong Opoku Agyemang
- Faddal Ibrahim
- Samuel Opoku-Agyemang
- Taiwo John
- Abdullai Tahiru

## Get Started

Import and set up like this, and you are good to go.

```javascript
import {
  FormGenerator,
  Button,
  Checkbox,
} from "@kehillahglobal/ui";
import "@kehillahglobal/ui/dist/index.css";
```

## Documentation

You may browse through the documentation of the various components available, via this link.
<a href ="https://kehillahglobal-ui-documentation.netlify.app/">Documentation Site </a>
<small>Kehillah-Global@2022</small>


## Components
 - Accordion
 - Button
 - Checkbox
 - CheckboxGroup
 - CircularProgressBar
 - Dropdown
 - FormGenerator
 - LinearProgressBar
 - Modal
 - ProgressBar
 - RadioGroup
 - Shimmer
 - Sidebar
 - Spinner
 - Table, 
 - Tag
 - Textbox
 - ToggleButton
 - Tooltip
 - Stepper
 - NoItems
 - TabView
 - Toast
 - DateRangePicker
npm package: @kehrwasser-dev/features
Description: feature management, smoke testing, A/B testing
Latest version: 0.7.3

# Kehrwasser Features: A Feature Toggle, SmokeTest, and A/B Testing Library

## Introduction

_Kehrwasser Features_ provides a comprehensive solution for managing feature toggles, smoke tests, and A/B testing within your application.
It offers a flexible way to control feature visibility, validate core functionalities, and experiment with different variations of your product.

## Installation

```bash
npm install @kehrwasser/features
```

## Usage

### Feature Toggles

Define feature flags:

```ts
// TODO
```

Check feature status:

```ts
// TODO
```

### Smoke Tests

Define smoke tests:

```ts
// TODO
```

Run smoke tests:

```ts
// TODO
```

### A/B Testing

Define A/B tests:

```ts
// TODO
```

Get variant:

```ts
// TODO
```

## Configuration

The library provides options for customizing behavior:

- Feature toggle storage: Configure where feature flags are stored (e.g., local storage, server-side configuration).
- A/B test targeting: Specify criteria for assigning users to test variants.
- Analytics: Track A/B test performance based on user interactions
- Role based feature toggles

## License

This library is licensed under the MIT License.