open-index/open-npm huggingface dataset:
npm package: @spalger/next-plus
Description: A couple helpers for working with next.js
Author: Spencer Alger
Latest version: 0.0.2

# @spalger/next-plus

A couple helpers for working with [`next.js`](https://github.com/zeit/next.js)

## Routing

### `createNextHandler`

Create a next.js handler, which is just a micro handler that takes `NextRoute` objects instead. `NextRoute` objects are just `Route` objects that don't specify their path, since next.js handles
routing via the file-system.

Signature:
```ts
interface Options {
  routes: NextRoute[],

  /**
   * global request handler that can return a response to take over requests
   */
  onRequest?: (ctx: ReqContext) => Promise<RouteResponse | void> | RouteResponse | void,

  /**
   * Array of exact origin header values that will authorize cors pre-flight requests
   */
  corsAllowOrigins?: string[]

  /**
   * Object with methods that will be called while a request is processed, see `./src/hooks.ts`
   */
  hooks?: Hooks
}

function createNextHandler(options: Options | NextRoute[]): (req: IncomingMessage, res: ServerResponse) => void
```

Example:
```js
import { createNextHandler, assertValidJwtAuthrorization, getConfigVar } from '@spalger/next-plus'

module.exports = createNextHandler({
  onRequest(ctx) {
    assertValidJwtAuthrorization(ctx, getConfigVar('JWT_SECRET'))
  },

  routes: [
    new NextRoute('GET', (ctx) => ({
      status: 200,
      body: 'bar'
    }))
  ],
})
```


### `NextRoute`

Signature:
```ts
new NextRoute(
  // valid request method for this route
  method: string,
  // function to execute when requests are received
  handler: (ctx: ReqContext) => Promise<RouteResponse> | RouteResponse,
)
```

Simplified version of `Route` for use with [next.js dynamic routing](https://nextjs.org/docs#dynamic-routing).


### `ReqContext`

See [@spalger/micro-plus `ReqContext` docs](https://github.com/spalger/micro-plus#reqcontext)

### `RouteResponse`

See [@spalger/micro-plus `RouteResponse` docs](https://github.com/spalger/micro-plus#routeresponse)

## Errors

See [@spalger/micro-plus "Errors" docs](https://github.com/spalger/micro-plus#errors)

## Config

See [@spalger/micro-plus "Config" docs](https://github.com/spalger/micro-plus#config)

## JWT

See [@spalger/micro-plus "JWT" docs](https://github.com/spalger/micro-plus#jwt)


## Search Params

See [@spalger/micro-plus "Search Params" docs](https://github.com/spalger/micro-plus#search-params)
npm package: @spalger/numeral
Description: Format and manipulate numbers.
Latest version: 2.2.1
Deprecated: no longer in use, use @elastic/numeral instead

# numeral.js

A javascript library for formatting and manipulating numbers. Forked from https://github.com/adamwdraper/Numeral-js

# Acknowlegements

Numeral.js, while less complex, was inspired by and heavily borrowed from [Moment.js](http://momentjs.com)


# License

Numeral.js is freely distributable under the terms of the MIT license. See the [LICENSE](LICENSE) file.
npm package: @spalger/redux-async-actions
Description: Simple action middleware and creator for redux actions that resolve to a promise.
Author: Spencer Alger
Latest version: 0.0.2

# @spalger/redux-async-actions

A simple wrapper around async redux actions.

## Install:

```sh
npm install --save @spalger/async-redux-actions
```

## Setup:


Start off by writing some async actions; FSAs with a `Promise` as their payload. Then add some `asyncHandlers`, which combined with `handleActions` (from `redux-actions`) and `combineReducers` (from `redux`) will make up your reducer. Finally tie it all together with with the `asyncActionsMiddleware` when you create your store.


**actions.js**
```js
import { users } from './api'

export const LOAD_USER = 'LOAD_USER'

export function loadUser(id) {
  return {
    type: LOAD_USER,
    payload: users.load(id),
  }
}
```

**reducer.js**
```js
import { combineReducers } from 'redux'
import { handleActions } from 'redux-actions'
import { asyncHandlers } from '../'

import { LOAD_USER } from './actions'

export default combineReducers({
  user: handleActions(asyncHandlers(LOAD_USER), {}),
})
```

**store.js**
```js
import { createStore, applyMiddleware } from 'redux'
import { middleware as asyncActionsMiddleware } from '../'

import reducer from './reducer'
const initialState = {}
const enhancer = applyMiddleware(asyncActionsMiddleware)

export default createStore(reducer, initialState, enhancer)
```

When dispatched, the payload of the `LOAD_USER` action will cause the following actions to dispatch, and cause the following state updates:

| step | action | state |
| --- | --- | --- |
| 1 | `{ type: '@@async/START/LOAD_USER' }` | `{ user: { ready: false} }` |
| 2a | `{ type: '@@async/SUCCESS/LOAD_USER' }` | `{ user: { ready: true, result: User } }` |
| 2b | `{ type: '@@async/FAILURE/LOAD_USER' }` | `{ user: { ready: true, error } }` |

To modify the resulting states you can supply handlers to `handleActions(ACTION, handlers)`:

```js
const reducers = combineReducers({
  user: handleActions(asyncHandlers(LOAD_USER, {
    start: () => ({ fetching: true }),               
    success: (state, payload) => ({ user: payload }),
    error: (state, payload) => ({ reason: payload })
  }, {}))
})

// states produced:
//  on start:    { user: { ready: false, fetching: true } }
//  on success:  { user: { ready: true, user: User } }
//  on failure:  { user: { ready: true, reason: error } }
```

You can simplify the handlers by just supplying a function, which will simply be used for the success handler:

```js
const reducers = combineReducers({
  user: handleActions(asyncHandlers(LOAD_USER, (state, payload) => ({ user: payload })), {})
})

// states produced:
//  on start:    { user: { ready: false } }
//  on success:  { user: { ready: true, user: User } }
//  on failure:  { user: { ready: true, error: error } }
```