open-index/open-npm huggingface dataset:
npm package: @isogon/eslint-config
Description: The way all isogon code should look.
Latest version: 0.0.13

# @isogon/eslint-config

## Installation

  1. `yarn add -D @isogon/eslint-config`

  2. Install our peer dependencies.
    If you are on linux you can run `yarn info @isogon/eslint-config peerDependencies --json | command sed 's/[\{\},]//g ; s/: /@/g' | xargs yarn add -D`

## Usage

### Simple usage

Create a lint script for yarn to run

```json
{
  "scripts": {
    "lint": "eslint -c @isogon ."
  }
}
```

### If you need to tweak it

Create `.eslint-config`, and create a lint script that yarn can run in your `package.json`:

```json
{
  "extends": "@isogon"
}
```

```json
{
  "scripts": {
    "lint": "eslint ."
  }
}
```
npm package: @isogon/inject
Description: A middleware that injects dependencies for redux action creators
Latest version: 0.0.11

@isogon/inject
==============

@isogon/inject is a simple way to allow you to dispatch a function that gets injected later.

```js
import {
  createStore,
  applyMiddleware,
  compose,
} from 'redux';
import inject from '@isogon/inject';

import reducer from './reducers'; // Your reducers
import someHelper from './someHelper'; // Something you need in your actions

const initialState = {};
const middleware = applyMiddleware(inject({
  someHelper,
});
const store = compose(middleware)(createStore)(reducer, initialState);

store.dispatch(({ someHelper }) => someHelper('DO_THE_THING'));
```
npm package: @isogon/tuple-map
Description: A simple way to map a tuple to some value
Author: Kegan Myers
Latest version: 0.0.4

TupleMap
========

Have you ever wanted to store some value against a tuple? If yes, thos can help. If no, why are you even here?

I wanted to do this so I could easily cache differences between objects, so I did it. Hopefully someone else finds some use from it.

NB: Despite what I claim, this is not a map, but a trie/nested maps.

Usage
-----

```javascript
import TupleMap from '@isogon/tuple-map';

const tm = new TupleMap(3); // it takes the size of the tuple

const objTuple = [{}, {}, {}];

// `set` returns the instance so you can chain calls.
tm
  .set(objTuple, 1000000)
  .set([1, 2, 3], 4)

expect(tm.get(objTuple), 'retrieval works').equal(1000000);
expect(tm.get([{}, {}, {}]), 'follows standard map semantics').equal(undefined);

expect(tm.get([1, 2, 3]), 'primitives work as expected').equal(4);
```

Compatibility
-------------

It should work in any browser/runtime with native support for `Map` and `class`. (Recent browsers except Opera/IE, node >= 6).