open-index/open-npm huggingface dataset:
npm package: @knights-of-the-editing-table/spell-book
Description: Add Spell Book support to an extension. Execute actions with shortcuts or control surface.
Author: Ivan Stepanov, Knights of the Editing Table
Latest version: 1.0.3

# Spell Book

Spell Book is a support app to listen for a shortcut or a control surface button press in Adobe apps, to trigger extension commands.
This module provides an interface for registering commands and handling shortcuts in your Adobe extension.

## Installation

```bash
npm install @knights-of-the-editing-table/spell-book
```

## Usage

### Basic Setup

```javascript
import Spellbook from '@knights-of-the-editing-table/spell-book';

const commands = [
    {
        commandID: 'command.id',
        name: 'Command 1', // use localised name if needed
        group: 'Group 1', // optional
        action: () => { // run action when command is triggered
            console.log('command.id triggered!')
        }
    }
];

const spellbook = new Spellbook('Extension name', 'extension.id', commands);
```

### Command Interface

```javascript
/**
 * @typedef {Object} Command
 * @property {string} commandID - Unique identifier for the command
 * @property {string} name - Display name for the command
 * @property {string?} group - Name of group the command belongs to
 * @property {(args?: any) => void} [action] - Function to execute when command is triggered
 */
```

## API Reference

### Spellbook

#### Constructor

```javascript
new Spellbook(
    pluginName: string,
    pluginID: string,
    commands?: Command[])
```

#### Methods

- `register(commands: Command[]): void` - Add or update commands
- `start(): void` - Start listening for command events
- `stop(): void` - Stop listening for command events

#### Events

The plugin extends EventEmitter and emits events when commands are triggered:

```javascript
spellbook.on('command.id', (commandID) => {
    console.log('command.id triggered!')
});
```

## Supported Adobe Hosts
- Premiere Pro
- After Effects
- Photoshop (CEP)
- Illustrator
- InDesign

## Integration with Adobe CEP

This module is designed to work with Adobe CEP extensions and uses the native `window.__adobe_cep__` interface.
Make sure that Spell Book is installed (both app and Spell Book extension).

## UXP support

Use UXP Spellbook plugin:
https://www.npmjs.com/package/@knights-of-the-editing-table/spell-book-uxp

## License

MIT License - see LICENSE file for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
npm package: @knights-of-the-editing-table/spell-book-uxp
Description: Add Spell Book support to an extension. Execute actions with shortcuts or control surface.
Author: Ivan Stepanov, Knights of the Editing Table
Latest version: 1.0.1

# Spell Book UXP

Spell Book is a support app to listen for a shortcut or a control surface button press in Adobe apps,
to trigger extension commands.
This module provides an interface for registering commands and handling shortcuts in your Adobe extension.

## Installation

```bash
npm install @knights-of-the-editing-table/spell-book-uxp
```

## Usage

### Basic Setup

Add command entrypoint and enablePluginCommunication to manifest.json, for [Inter Plugin Communication](https://developer.adobe.com/indesign/uxp/plugins/tutorials/inter-plugin-comm/):
```json
{
    "entrypoints": [
        {
            "type": "command",
            "id": "spellbook.plugin",
            "label": {
                "default": "- spellbook plugin" // you can use your label
            }
        }
    ],
    "requiredPermissions": {
        "ipc": {
            "enablePluginCommunication": true
        }
    }
}
```

Add Spell Book plugin:
```javascript
import Spellbook from '@knights-of-the-editing-table/spell-book-uxp';

const commands = [
    {
        commandID: 'command.id',
        name: 'Command 1', // use localised name if needed
        group: 'Group 1', // optional
        action: () => { // run action when command is triggered
            console.log('command.id triggered!')
        }
    }
];

const spellbook = new Spellbook('Extension name', 'extension.id', commands);

// add spellbook.plugin to entry points
const { entrypoints } = require("uxp");
entrypoints.setup({
    commands: {
        'spellbook.plugin': {
            run: (data, args) => spellbook.plugin(data, args),
        },
    },
});
```

### Command Interface

```javascript
/**
 * @typedef {Object} Command
 * @property {string} commandID - Unique identifier for the command
 * @property {string} name - Display name for the command
 * @property {string?} group - Name of group the command belongs to
 * @property {(args?: any) => void} [action] - Function to execute when command is triggered
 */
```

## API Reference

### Spellbook

#### Constructor
```javascript
new Spellbook(
    pluginName: string,
    pluginID: string,
    commands?: Command[])
```

#### Methods
- `register(commands: Command[]): void` - Add or update commands
- `start(): void` - Start listening for command events
- `stop(): void` - Stop listening for command events

#### Events
The plugin extends EventEmitter and emits events when commands are triggered:

```javascript
spellbook.on('command.id', () => {
    console.log('command.id triggered!')
});
```

## Supported Adobe Hosts
- Premiere Pro
- Photoshop
- InDesign

## Integration with Adobe UXP
Make sure that Spell Book is installed (both app and Spell Book extension).

## CEP support
For CEP use [@knights-of-the-editing-table/spell-book](https://www.npmjs.com/package/@knights-of-the-editing-table/spell-book)

## License
MIT License - see LICENSE file for details.
npm package: @knightshrestha/rich_text_editor
Description: A simple rich text editor.
Author: Knight Shrestha
Latest version: 0.0.2


# Rich Text Editor

A simple rich text editor.


## Badges

[![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit/)

[![GitHub last commit](https://img.shields.io/github/last-commit/Knightshrestha/rte)
](https://github.com/Knightshrestha/rte)

[![NPM Version](https://img.shields.io/npm/v/%40knightshrestha%2Frich_text_editor)](https://www.npmjs.com/package/@knightshrestha/rich_text_editor)




## Screenshots

![App Screenshot](https://via.placeholder.com/468x300?text=App+Screenshot+Here)


## Features

- Rich Text Editor with svelte and tiptap


## Installation

Install my-project with npm

```bash
npm install @knightshrestha/rich_text_editor
```
    
## Usage/Examples

```svelte
<script lang="ts">
  import RichTextEditor from "$lib/components/RTE.svelte";

  let description = $state('');
</script>

<RichTextEditor
  initialValue={description}
  onChange={(data: string) => {
    description = data;
  }}
/>
```


## License

This library is released under [MIT](https://choosealicense.com/licenses/mit/) licence.


## Tech Stack

 - **[DaisyUI](https://daisyui.com/)**
 - **[Tiptap](https://tiptap.dev/docs)**
 - **[Svelte Tiptap](https://github.com/sibiraj-s/svelte-tiptap)**
npm package: @knighttower/vue-mixin-installer
Description: Helps to install a mixin in Vue 2 or 3 for both options and composition API
Author: knighttower
Latest version: 1.0.2
Deprecated: this package has been migrated as part of a monorepo it is now under @knighttower/utility (https://www.npmjs.com/package/@knighttower/utility) and also included in knighttower monorepo (https://www.npmjs.com/package/knighttower)

# VueMixinInstaller
Helps to install a mixin in Vue 2 or 3 for both options and composition API

```javascript
/**
 * Supports both, Options & Composition API
 * Use to install mixins that can work with both APIs
 * @mixin installMixin
 * @param {Object} object Mixin object
 * @param {String} name Register name to be used as
 * @example
 * In Application
 * 1. Import your mixin into your app
 *    import { installMixin } from '@knighttower/vue-mixin-installer'; //import into your app
 * 2. register your mixin with the application
 *    app.use(installMixin(ExampleMixinObject<object>, 'NameThatWillBeAssignedToYourMixin'<string>)); //registers your mixin
 * Or Inside your mixin
 *  1. Import into your mixin and use like this
 *      import { installMixin } from '@knighttower/vue-mixin-installer'; //import into your mixin
 *      // ... your mixin code here
 *      export default installMixin(ExampleMixinObject, 'ExportTableHelper'); //exports your mixin
 * 2. Import into your app and use like this
 *      import ExampleMixinObject from '@/mixins/ExampleMixinObject'; //import into your app
 *      app.use(ExampleMixinObject); //registers your mixin
 * 3. Use in your component like this
 *     In Option API: this.YourMixinMethod()
 *     In Composition API: const { YourMixinMethod } = inject('YourMixinMethod');
 *     Or In Composition API: const CustomName = inject('YourMixinMethod'); then CustomName.YourMixinMethod()
 *  
 * @returns {Object} Registration instance used by VUE
 */
```

## Usage  

``npm install @knighttower/vue-mixin-installer``  
``yarn add @knighttower/vue-mixin-installer``  

``import { installMixin } from '@knighttower/vue-mixin-installer';``  

## Other
Checkout my profile https://github.com/knighttower or https://knighttower.io for more cool freebies and awesome VUE/Laravel/PHP projects
npm package: @knighttower/vue-utils
Description: Helps to install a mixin in Vue 2 or 3 for both options and composition API
Author: knighttower
Latest version: 1.0.18

ℹ This package is part of the [Js utility](https://github.com/knighttower/JsUtility) collection of packages (monorepo)  

# MixinInstaller
Helps to install a mixin in Vue 2 or 3 for both options and composition API

```javascript
/**
 * Supports both, Options & Composition API
 * Use to install mixins that can work with both APIs
 * @mixin installMixin
 * @param {Object} object Mixin object
 * @param {String} name Register name to be used as
 * @example
 * In Application
 * 1. Import your mixin into your app
 *    import { installMixin } from '@knighttower/vue-mixin-installer'; //import into your app
 * 2. register your mixin with the application
 *    app.use(installMixin(ExampleMixinObject<object>, 'NameThatWillBeAssignedToYourMixin'<string>)); //registers your mixin
 * Or Inside your mixin
 *  1. Import into your mixin and use like this
 *      import { installMixin } from '@knighttower/vue-mixin-installer'; //import into your mixin
 *      // ... your mixin code here
 *      export default installMixin(ExampleMixinObject, 'ExportTableHelper'); //exports your mixin
 * 2. Import into your app and use like this
 *      import ExampleMixinObject from '@/mixins/ExampleMixinObject'; //import into your app
 *      app.use(ExampleMixinObject); //registers your mixin
 * 3. Use in your component like this
 *     In Option API: this.YourMixinMethod()
 *     In Composition API: const { YourMixinMethod } = inject('YourMixinMethod');
 *     Or In Composition API: const CustomName = inject('YourMixinMethod'); then CustomName.YourMixinMethod()
 *  
 * @returns {Object} Registration instance used by VUE
 */
```

## Usage  

``npm install @knighttower/vue-utils``  

``import { installMixin } from '@knighttower/vue-utils/mixinInstaller';``  

## Other
Checkout my profile https://github.com/knighttower or https://knighttower.io for more cool freebies and awesome VUE/Laravel/PHP projects
npm package: @knightus/swig-loader
Description: Webpack loader for swig templates
Author: Paweł Mendelski
Latest version: 2.1.0

# Webpack Swig loader

[![Travis build status](https://travis-ci.org/coditorium/nodejs-swig-loader.png?branch=master)](https://travis-ci.org/coditorium/nodejs-swig-loader)
[![dependencies](https://david-dm.org/coditorium/nodejs-swig-loader.png)](https://david-dm.org/coditorium/nodejs-swig-loader)
[![Coverage Status](https://coveralls.io/repos/coditorium/nodejs-swig-loader/badge.svg)](https://coveralls.io/r/coditorium/nodejs-swig-loader)

[![NPM info](https://nodei.co/npm/swig-loader.png?downloads=true)](https://www.npmjs.com/package/swig-loader)

Webpack loader for [swig](http://paularmstrong.github.io/swig) templates.

## How to use

### Webpack configuration

You can define swig loader using webpack configuration.

``` javascript
{
  module: {
    loaders: [
      { test: /\.swig$/, loader: "swig-loader" }
    ]
  }
};
```

### Require parameter

You can load swig template using require parameter.

``` javascript
var template = require('swig!./template.swig');
```

### Passing swig options

You can pass [swig options](http://paularmstrong.github.io/swig/docs/api/#SwigOpts) to the loader using `swigLoader.options({ ... })` or loader query parameters. If you choose loader query parameters take a look at query [webpack standard query format](https://github.com/webpack/loader-utils#parsequery).

``` javascript
// Option #1 - Swig loader global options
var swigLoader = require('swig-loader');
swigLoader.options({
  varControls: ['{:', ':}']
});

// Option #2 - Swig loader query parameters
var swigLoader = require('swig?varControls[]={:&varControls[]=:}!./template.swig');
```

### Passing template parameters

You can pass template parameters to the loader using resource query parameters. If you need to pass some parameters take a look at query [webpack standard query format](https://github.com/webpack/loader-utils#parsequery).

``` javascript
var swigLoader = require('swig!./template.swig?username=John');
```

### Customizers

You can customize `query`, `resourceQuery` and `result` using customizers:

``` javascript
var swigLoader = require('swig-loader');

swigLoader.queryCustomizer(function(query, templatepath) {
    // modify query
});

swigLoader.resourceQueryCustomizer(function(resourceQuery, templatepath) {
    // modify resource query
});

swigLoader.resultCustomizer(function(query, templatepath, resourceQuery, query) {
    // modify result and don't forget to return it!
    return result;
});
```
npm package: @knijtram/vue-infinite-scroller
Description: An infinite scroller for Vue
Author: Martijn Kuipers
Latest version: 1.1.0

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Test Suite](https://github.com/knijtram/vue_infinite_scroller/actions/workflows/ci.yml/badge.svg)](https://github.com/OWNER/REPO/actions/workflows/ci.yml)
![Release Version](https://img.shields.io/github/v/release/knijtram/vue_infinite_scroller?label=latest)
![Free](https://img.shields.io/badge/free-open--source-green.svg)

# Vue Infinite Scroller

A simple and efficient Vue 3 component designed for smoothly displaying large lists of items through infinite scrolling.

## Overview

Vue Infinite Scroller provides an intuitive, high-performance solution for handling large data sets by dynamically loading items as users scroll. Ideal for applications requiring optimized rendering of extensive lists such as user lists, product catalogs, location browsers, or log entries.

## Features

- **Efficient rendering:** Loads and renders items incrementally, improving page load times.
- **Easy integration:** Quickly integrates into any Vue 3 project.
- **Customizable:** Configurable options allow flexible control over loading and display behavior.

## Installation

Install via npm:

```bash
npm install @knijtram/vue-infinite-scroller
```

### Prerequisites

- Vue 3

## Usage

For detailed usage examples, please refer to the demo folder in the [repository](#).

Basic implementation:

```vue
<template>
  <InfiniteScroller :items="items" :initialCount="10" :batchSize="10">
    <template #default="{ item }">
      <!-- Custom rendering logic -->
      <div>{{ item }}</div>
    </template>
  </InfiniteScroller>
</template>

<script>
import { ref } from 'vue';
import InfiniteScroller from '@knijtram/vue-infinite-scroller';

export default {
  components: { InfiniteScroller },
  setup() {
    const items = ref([...]); // Your data here
    return { items };
  }
};
</script>
```

## Configuration

The component can be customized with the following props:

| Prop           | Type   | Description                                | Default |
| -------------- | ------ | ------------------------------------------ | ------- |
| `items`        | Array  | List of items to display.                  | `[]`    |
| `initialCount` | Number | Initial number of items displayed on load. | `10`    |
| `batchSize`    | Number | Number of items to load per scroll event.  | `10`    |

## License

This project is licensed under the MIT License.

## Author

Martijn Kuipers

<a href="https://www.buymeacoffee.com/knijtram" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" style="height: 60px !important;width: 217px !important;" ></a>
npm package: @knine-sdk/constants
Description: Constants for K9 Finance projects.
Latest version: 1.21.1

# Constants

Constants for K9 Finance projects.

- [Install](#install)
- [Chains](#chains)
  - [Chains enum](#chains-enum)
  - [Array of chains ids](#array-of-chains-ids)
  - [getChainColor](#getchaincolor)
- [Tokens](#tokens)
  - [Tokens enum](#tokens-enum)
  - [getTokenAddress](#gettokenaddress)
- [Aggregator](#aggregator)
  - [getAggregatorAddress](#getaggregatoraddress)
- [WithdrawalQueue](#withdrawalqueue)
  - [getWithdrawalQueueAddress](#getWithdrawalQueueAddress)

## Install

```bash
yarn add @knine-sdk/constants
```

## Chains

[Source](src/chains.ts)

### Chains enum

```ts
import { CHAINS } from '@knine-sdk/constants';

console.log(CHAINS.Mainnet, CHAINS.Sepolia); // 1, 17000
```

### Array of chains ids

```ts
import { CHAINS_IDS } from '@knine-sdk/constants';

console.log(CHAINS_IDS); // [1, 3, 4, 5, 42]
```

### getChainColor

Color getter by chain id

```ts
import { CHAINS, getChainColor } from '@knine-sdk/constants';

const goerliChainColor = getChainColor(CHAINS.Goerli);
console.log(goerliChainColor); // #3099f2
```

## Tokens

[Source](src/tokens.ts)

### Tokens enum

```ts
import { TOKENS } from '@knine-sdk/constants';

console.log(TOKENS.BONE); // STETH
console.log(TOKENS.KNBONE); // LDO
```

### getTokenAddress

Getter for Knine token addresses. Returns a contract address or throws an error if the contract is not deployed in the chain.

```ts
import { CHAINS, TOKENS, getTokenAddress } from '@knine-sdk/constants';

const stethAddress = getTokenAddress(CHAINS.Mainnet, TOKENS.STETH);
console.log(stethAddress); // 0xae7ab96520de3a18e5e111b5eaab095312d7fe84
```

## Aggregator

[Source](src/aggregator.ts)

EACAggregatorProxy https://etherscan.io/address/0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419  
It’s used to get the ETH price

### getAggregatorAddress

```ts
import { CHAINS, getAggregatorAddress } from '@knine-sdk/constants';

const aggregatorAddress = getAggregatorAddress(CHAINS.Mainnet);
console.log(aggregatorAddress); // 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419
```

## WithdrawalQueue

WithdrawalQueue contract for KNINE protocol

### getWithdrawalQueueAddress

```ts
import { CHAINS, getWithdrawalQueueAddress } from '@knine-sdk/constants';

const withdrawalQueueAddress = getWithdrawalQueueAddress(CHAINS.Mainnet);
console.log(withdrawalQueueAddress); // 0x889edC2eDab5f40e902b864aD4d7AdE8E412F9B1
```
npm package: @knine-sdk/fetch
Description: Fetchers for Knine projects.
Latest version: 1.0.29

# Fetchers

Fetchers for Knine projects.

- [Install](#install)
- [Fetch](#fetch)
- [Fetch With Fallbacks](#fetch-with-fallbacks)
- [Fetch RPC](#fetch-rpc)
  - [Options](#options)
- [Helpers](#helpers)
  - [getInfuraRPCUrl](#getinfurarpcurl)
  - [getAlchemyRPCUrl](#getalchemyrpcurl)

## Install

```bash
yarn add @knine-sdk/fetch
```

## Fetch

node-fetch package [NPM](https://www.npmjs.com/package/node-fetch), [Github](https://github.com/node-fetch/node-fetch)

```ts
import { fetch } from '@knine-sdk/fetch';

const response = await fetch('https://example.com');
const result = await response.json();
```

## Fetch With Fallbacks

[Source](src/fetchWithFallbacks.ts)

A wrapper over `fetch` which takes an array of URLs instead of a single URL. If a request throws an exception, it takes the following URL from the array and repeats the request to it.

```ts
import { fetchWithFallbacks } from '@knine-sdk/fetch';

const urls = ['https://example.com', 'https://fallback.com'];

const response = await fetchWithFallbacks(urls);
const result = await response.json();
```

## Fetch RPC

[Source](src/fetchRPC.ts)

A wrapper over `fetchWithFallbacks`, which is useful as a backend part of proxying RPC requests from frontend to API provider.

```ts
import { fetchRPC } from '@knine-sdk/fetch';

const options = {
  urls: [
    'http://your_rpc_server.url',
    (chainId) => `http://your_rpc_server.url/?chainId=${chainId}`,
  ],
  providers: {
    infura: 'INFURA_API_KEY',
    alchemy: 'ALCHEMY_API_KEY',
  },
};

const rpc = async (req, res) => {
  // chainId and body from request
  const chainId = Number(req.query.chainId);
  const body = JSON.stringify(req.body);

  const response = await fetchRPC(chainId, { body, ...options });
  const result = await response.json();

  res.json(result);
};
```

### Options

Options extend `RequestInit` interface with the `urls` and `providers`. `urls` have priority over `providers`.

```tsx
import { CHAINS } from '@knine-sdk/constants';
import { RequestInit } from 'node-fetch';

interface FetchRPCOptions extends RequestInit {
  providers?: {
    infura?: string;
    alchemy?: string;
  };
  urls?: Array<string, (chainId: CHAINS) => string>;
}
```

## Helpers

[Source](src/providersUrls.ts)

### getInfuraRPCUrl

Returns [infura](https://infura.io/) endpoint for API key and chainId

```ts
import { getInfuraRPCUrl } from '@knine-sdk/fetch';
import { CHAINS } from '@knine-sdk/constants';

const url = getInfuraRPCUrl(CHAINS.Mainnet, 'YOUR_API_KEY');
console.log(url); // https://mainnet.infura.io/v3/YOUR_API_KEY
```

### getAlchemyRPCUrl

Returns [alchemy](https://www.alchemy.com/) endpoint for API key and chainId

```ts
import { getAlchemyRPCUrl } from '@knine-sdk/fetch';
import { CHAINS } from '@knine-sdk/constants';

const url = getAlchemyRPCUrl(CHAINS.Mainnet, 'YOUR_API_KEY');
console.log(url); // https://eth-mainnet.alchemyapi.io/v2/YOUR_API_KEY
```
npm package: @knine-sdk/helpers
Description: Helpers for Knine projects. Part of Knine JS SDK
Latest version: 1.1.4

# Helpers

Helpers for Knine projects.
Part of Knine JS SDK

- [Install](#install)
- [Etherscan](#etherscan)
  - [getEtherscanTxLink](#getetherscantxlink)
  - [getEtherscanTokenLink](#getetherscantokenlink)
  - [getEtherscanAddressLink](#getetherscanaddresslink)
- [Open window](#open-window)

## Install

```bash
yarn add @knine-sdk/helpers
```

## Etherscan

A set of functions for generating links to [etherscan](https://etherscan.io/)

### getEtherscanTxLink

```ts
import { getEtherscanTxLink } from '@knine-sdk/helpers';
import { CHAINS } from '@knine-sdk/constants';

const link = getEtherscanTxLink(
  CHAINS.Mainnet,
  '0x0000000000000000000000000000000000000000000000000000000000000000',
);
console.log(link); // https://etherscan.io/tx/0x0000000000000000000000000000000000000000000000000000000000000000
```

### getEtherscanTokenLink

```ts
import { getEtherscanTokenLink } from '@knine-sdk/helpers';
import { CHAINS } from '@knine-sdk/constants';

const link = getEtherscanTokenLink(
  CHAINS.Mainnet,
  '0x0000000000000000000000000000000000000000',
);
console.log(link); // https://etherscan.io/address/0x0000000000000000000000000000000000000000
```

### getEtherscanAddressLink

```ts
import { getEtherscanAddressLink } from '@knine-sdk/helpers';
import { CHAINS } from '@knine-sdk/constants';

const link = getEtherscanAddressLink(
  CHAINS.Mainnet,
  '0x0000000000000000000000000000000000000000',
);
console.log(link); // https://etherscan.io/address/0x0000000000000000000000000000000000000000
```

## Open window

```ts
import { openWindow } from '@knine-sdk/helpers';

openWindow('https://knine.io');
```
npm package: @knit/babel-plugin-socks-relay
Description: Relay babel plugins
Author: Shane Wilson
Latest version: 0.3.3

# Babel Relay Plugin

Babel plugin for getting GraphQL schema from server.

## Install

```
yarn add @knit/babel-plugin-socks-relay
```

## Usage

```
// .babelrc
{
  plugins: ['@knit/socks-relay']
}
```
npm package: @knit/babel-preset-socks-react
Description: A pair of babel socks
Author: Shane Wilson
Latest version: 0.5.0

# Babel Preset

Babel preset used by KnitJS

## Install

```
yarn add @knit/babel-preset-socks
```

## Usage

```
// .babelrc
{
  presets: ['@knit/socks']
}
```
npm package: @knit/eslint-config-socks
Description: A pair of plain eslint socks
Author: Shane Wilson
Latest version: 0.2.0

# ESLint Config

ESLint config designed for node apps used by KnitJS.

## Install

```
yarn add @knit/eslint-config-socks
```

## Usage

```
// .eslintrc
{
  extends: ['@knit/socks']
}
```
npm package: @knit/eslint-config-socks-react
Description: A pair of react eslint socks
Author: Shane Wilson
Latest version: 0.2.0

# ESLint React Config

ESLint config designed for React apps used by KnitJS.

## Install

```
yarn add @knit/eslint-config-socks-react
```

## Usage

```
// .eslintrc
{
  extends: ['@knit/socks-react']
}
```
npm package: @knit/jest-config-socks
Description: A pair of jest socks
Author: Shane Wilson
Latest version: 0.6.0

# Jest Config

Jest config used by KnitJS.

## Install

```
yarn add @knit/jest-config-socks
```

## Usage

```
const jestConfig = require('@knit/jest-config-socks');
const jest = require('jest');

const opts = ['--config', JSON.stringify(jestConfig())];
jest.run(opts);
```