open-index/open-npm huggingface dataset:
npm package: @mmintel/nuxt-datocms
Description: Connects DatoCMS with Nuxt
Latest version: 0.0.9

# datocms

[![npm version][npm-version-src]][npm-version-href]
[![npm downloads][npm-downloads-src]][npm-downloads-href]
[![Circle CI][circle-ci-src]][circle-ci-href]
[![Codecov][codecov-src]][codecov-href]
[![License][license-src]][license-href]

> Connects DatoCMS with Nuxt

[📖 **Release Notes**](./CHANGELOG.md)

## Setup

1. Add `datocms` dependency to your project

```bash
npm i @mmintel/nuxt-datocms
```

2. Add `datocms` to the `modules` section of `nuxt.config.js`

```js
{
  modules: [
    // Simple usage
    '@mmintel/nuxt-datocms',

    // With options
    ['@mmintel/nuxt-datocms', { /* module options */ }]
  ],
  // or place options here
  datocms: {
    // module options
  }
}
```

## Options
`apiKey`: read-only API key for DatoCMS
`httpEndpoint`: mainly for testing, but maybe DatoCMS will one day change it's API url, who knows..

## Development

1. Clone this repository
2. Install dependencies using `yarn install` or `npm install`
3. Start development server using `npm run dev`

## License

[MIT License](./LICENSE)

Copyright (c) Marc Mintel <marc@mintel.me>

<!-- Badges -->
[npm-version-src]: https://img.shields.io/npm/v/datocms/latest.svg?style=flat-square
[npm-version-href]: https://npmjs.com/package/datocms

[npm-downloads-src]: https://img.shields.io/npm/dt/datocms.svg?style=flat-square
[npm-downloads-href]: https://npmjs.com/package/datocms

[circle-ci-src]: https://img.shields.io/circleci/project/github/.svg?style=flat-square
[circle-ci-href]: https://circleci.com/gh/

[codecov-src]: https://img.shields.io/codecov/c/github/.svg?style=flat-square
[codecov-href]: https://codecov.io/gh/

[license-src]: https://img.shields.io/npm/l/datocms.svg?style=flat-square
[license-href]: https://npmjs.com/package/datocms
npm package: @mmintel/react-primer
Description: react-primer React component
Latest version: 0.0.12

# react-primer

[![Travis][build-badge]][build] [![npm package][npm-badge]][npm] [![Coveralls][coveralls-badge]][coveralls]

# Requirements

- fela
- react-fela

# Usage

## Include theme

```javascript
import { ThemeProvider } from 'react-fela';
import { theme } from '@mmintel/react-primer';

const Layout = (props) => (
  <ThemeProvider theme={theme}>
    //...
  </ThemeProvider>
)
```
npm package: @mmintel/tachyons-sass
Description: Super flexible SCSS port of tachyons
Author: Marc Mintel
Latest version: 0.0.3

# tachyons-sass

Super flexible SCSS port of tachyons.

## Installation

```bash
npm install --save @mmintel/tachyons-sass
```

## Changes

* Breakpoints are used with `@` Suffx, e.g. `.fs3@ns`
* Breakpoints are now customizable, add new breakpoints to `$breakpoints` map
* Many settings are transformed into maps and automatically generate new classes when changed
    - `$font-sizes`
    - `$spacings`
    - `$sizes` (now used for widths and heights)
    - `$transparencies`
    - `$grays`
    - `$shadows`
    - `$text-shadows`
    - `$thicknesses`
    - `$radii`
* changed names of gray tones, now `.gray1`, `.gray2`...
* changed `.list` to `.no-list`
* changed `.mw` to `.max-w`
* added `.circle`
* added `.fill-*` classes, e.g. `.fill-gray5`
* added `.t-shadow*`
* removed colors completely
* removed `inherit` classes completely
* removed debugging classes
* removed unnecessary headline classes
    - `.f-headline`
    - `.f-subheadline`
    - `.f-5`
    - `.f-6`
* removed gradients
* removed font families
* removed hover effects

## Usage

```scss
@import "path/to/tachyons.scss";
```

## License

MIT

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request
npm package: @mmis1000/lit-jsx
Description: a jsx parser written with tagged template
Author: mmis1000
Latest version: 1.0.4

# [WIP] litJSX

A 10kb(minified) only JSX compiler running in browser  
Write React without tool chains!

# Example
```js        
var res = litJSX.jsx(React, {Tag: Tag})`
    <Tag ...${{test:"included"}}  v${"a"}l=t${"es"}t val1=t${"es"}t1 v${"a"}l2=test2/>
`

ReactDOM.render(
    res,
    document.getElementById('root')
);
```

# API

```js
/**
 * @param {React} React
 * @param {Object<string, Componenet>} componenets the templete will try to create element as string directly if it is not registerd here
 * @returns {function} The templete literal function
 */
var jsx = litJSX.jsx(React, {Component1, Component1, ...other});
```

```js
/**
 * @param {string[]} templete
 * @param {...any} argumenets
 * @returns {Element} react element
 */
jsx;
```

# Basic Usage
```js
// it will return the element if there is only one root element
jsx`
    <div></div>
`

// it will return a React.Fragment if there are more than one root element.
jsx`
    <div></div>
    <div></div>
`
```

# Supported Syntaxs

## common entities
```js
// it unesacpe only these entities in tag body and attribute value
jsx`
    <div value="&amp;&lt;&gt;&quot;&#039;&nbsp;">
        &amp;&lt;&gt;&quot;&#039;&nbsp;
    </div>
`
// you got &<>"'\u00A0 in both property and body
```
## self closed tag
```js
jsx`
    <div/>
`
```

## open tag
```js
jsx`
    <div>content</div>
`
```

## text only (will be wrapped into a fragment)
```js
jsx`
    There is only text
`
```

## fragment (although there is no reason to use it. It is automatically wrapped if there is more than one element at root)
```js
jsx`
    <>
        There is only text
    </>
`
```

## props
```js
jsx`
    <div attribute=x/>
    <div attribute='x'/>
    <div attribute="x"/>
`
```

## data in body
```js
jsx`
    <div>
        The data here can also be
        ${"text"}
        or
        ${jsx`another element`}
        or
        ${[jsx`array of elements`]}
        just like original jsx
    </div>
`
```

## data in key (will be stringfied and concat to other part)
```js
jsx`
    <div ${"key"}="value"/>
`
```

## only data in value (will not be stringfied)
```js
jsx`
    <div key=${12}/>
`
```

## mixed data in value (will be stringfied and concat to other part)
```js
jsx`
    <div key=${"val"}ue/>
`
```

## Object literal spread (will be mixed into the props by Object.assign)
```js
var ObjectToSpread = {key: "value"};
jsx`
    <div ...${ObjectToSpread}/>
`
```
npm package: @mmis1000/lowdb-split-json-adapter
Description: A storage adapter that save data into split json instead of a single file
Author: mmis1000
Latest version: 0.2.3

# Lowdb split JSON adapter

Unlike the original FileSync adapter from lowdb.  
This adapter split the JSON into multi files.  
And add additional template support.  
So you can have multi small JSON file instead of a giant one that lag your editor when mock large Services.

## Options

```ts
type AdapterOptions = {
    // This must be a object and not array
    defaultValue?: any
    // customize encode method
    serialize?: any => string
    // customize decode method
    deserialize?: string => any
}

class SplitJSONAdapter {
    /**
     * @param dirPath path to the directory that store JSON files
     * @param options optional options
     */
    constructor (dirPath: string, options: AdapterOptions = {}) {}
}
```

## Storage structure

Each field was a single json file, and the usage is determined by the file extension.

Available extensions:

1. .json  
    1. type: regular field
    2. mode: r/w
2. .template.json
    1. type: template a single field
    2. mode: r
3. .template.js
    1. type: template a single field.  
        Value of `module.exports` was used
    2. mode: r
4. .snapshot.json
    1. type: storage when try to write into read only `.template` field
    2. mode: r/w
5. .js
    1. type: template a single field.  
        Value of `module.exports` was used.  
        Value was **not** persistent into disk as `.snapshot.json`.
    2. mode: r

### When read the following dir

```txt
a.json
b.template.json
c.template.js
d.js
```

Will result in

```js
const object = {
    a: [/* ... */],
    b: [/* ... */],
    c: [/* ... */],
    d: [/* ... */]
}
```

### When you save above object the into the above dir

You get

```txt
a.json          // in place modified
b.template.json // untouched
b.snapshot.json // new
c.template.js   // untouched
c.snapshot.json // new
d.js            // untouched
```

So you can simply exclude all `.snapshot.json` from git or whatever while still keep it locally persistent.