open-index/open-npm huggingface dataset:
npm package: @hacknlove/textmaker
Description: Generate texts with a rich and descriptive microlanguage of recursive sustitutions
Author: Antonio Fernández Porrúa
Latest version: 1.0.0

# textmaker

[![HowTo](https://asciinema.org/a/mIAGbQ5zX9lAV8p1ZJ4391kh9.png)](https://asciinema.org/a/mIAGbQ5zX9lAV8p1ZJ4391kh9)

## Instalation
```
  npm install @hacknlove/textmaker
```

## Usage

```
  import TextMaker from { 'textmaker' }
  // // or
  // const TextMaker = require('textmaker')

  const textMaker = new TextMaker({
    description: ObjectWithTheTextsDescriptions,
    seed: "Some string, if you want your text to be predictable and replicable"
  })

  var text = textMaker.generate()
```

## Text description

The text description is a Javascrit Object that contains an array with the templates,  a bunch of sustitution arrays with more templates

you can check [example.json](example.json)

It contains string templates that includes plain text, **direct sustitutions** and **referenced sustitutions**

### Direct sustitutions

The template ``"I want [[cake-fruit-pie]]"`` will generate
* *I want cake*
* *I want fruit*
* *I want pie*

They can have as many options as you need, but if you need a lot of options you should consider using **referenced sustitutions** to keep your templates human readable.

They could be anidated so ``"I want [[some fresh [[fruit-juice]]-a piece of [[cake-pie]]"`` will generate
* *I want some fresh fruit*
* *I want some fresh juice*
* *I want a piece of cake*
* *I want a piece of pie*

You can nest as many options as you need, but you should consider using **referenced sustitutions** if you feel that you are loosing the vision of what is going there.

**Direct sustitutions** should be used to define quick simple choices.

### Referenced sustitutions

Direct sustitutions are words formed only by characters from `a-z`, `A-Z`, `0-9`, including the `_` (underscore), that starts with a `$`

For instance `"$foo"`, `"$bar"` `"$foo_bar"`

They match the javascript regexp `/\$[\w]+/` that is equivalent to `/\$[a-z0-9_]+/i`

They are sustituted for a random template of the array in `description` whose `key` matchs

#### Examples

```
  description = {
    templates: [
      "I want $dessert"
    ],
    $dessert: [
      "cake",
      "fruit",
      "pie"
    ]
  }
```

```
  description = {
    templates: [
      "I want $dessert"
    ],
    $dessert: [
      "some fresh $healthyDesert",
      "a piece of $unhealthyDessert"
    ],
    "$healthyDesert": [
      "fruit",
      "juice"
    ],
    "$unhealthyDesert": [
      "cake",
      "pie"
    ]
  }
```

### description.templates
This array contains the fist level templates, those that the generator picks in the first step.

It could be as complicated as you want, but it is preferable to keep them as simple as possible so they could be an index to the human eyes, so you can know at a glance what each one generates.

## Roadmap

* [] unit testing
* [] variable sustitution: ``"... (name:value) ..."`` establishs the variable that will replace `%name` in `"... %name ..."` as soon as possible.
npm package: @hacknug/palx
Description: Automatic UI Color Palette Generator
Author: Brent Jackson
Latest version: 1.0.4


# Palx

Automatic UI Color Palette Generator

https://palx.jxnblk.com

```js
npm i palx
```

Provide a single color value and Palx returns a full-spectrum color palette,
well suited for UI design and data visualizations that work harmoniously with brand colors.

```js
const palx = require('palx')

palx('#07c')
// Returns a color object with
// 12 hues and a gray spread across
// 10 luminance steps
```

## About

Inspired by [Open Color](https://yeun.github.io/open-color/),
Palx takes a single input color,
then spreads the hue across the color spectrum in 12 steps,
and spreads each hue across 10 luminance steps.
Palx also desaturates the main color to create shades of gray and a black that are based off the original color.

### Related

- [Hello Color](http://jxnblk.com/hello-color)
- [Colorable](http://jxnblk.com/colorable)
- [Monochrome](https://monochrome.jxnblk.com)
- [Grays](http://jxnblk.com/grays)
- [Shade](http://jxnblk.com/shade)
- [Spectral](http://jxnblk.com/Spectral)
- [Open Color](https://yeun.github.io/open-color)

MIT License
npm package: @hacknug/tailwindcss-alpha
Description: Automatic alpha variants for your Tailwind CSS colors
Author: Brad Cornes
Latest version: 1.0.1

# tailwindcss-alpha

> Automatic alpha variants for your Tailwind CSS colors

## Why?

If you’re like me your Tailwind CSS color configuration often ends up looking something like this:

```js
module.exports = {
  // ...
  backgroundColors: {
    red: '#f00',
    'red-10': 'rgba(255, 0, 0, 0.1)',
    'red-20': 'rgba(255, 0, 0, 0.2)',
    'red-50': 'rgba(255, 0, 0, 0.5)',
    'red-80': 'rgba(255, 0, 0, 0.8)'
    // ...
  }
  // ...
}
```

`tailwindcss-alpha` automatically generates alpha variations for each of your background, text, and border colors.

## Install

```
npm install --save-dev tailwindcss-alpha
```

```js
// tailwind.js
module.exports = {
  // ...
  plugins: [
    require('tailwindcss-alpha')({
      modules: {
        backgroundColors: true
      },
      alpha: {
        '10': 0.1,
        '30': 0.3
      }
    })
  ]
  // ...
}
```

## Options

### `modules` (optional)

**Default:** `{ backgroundColors: true, textColors: false, borderColors: false }`

Here is where you define which Tailwind modules you would like to generate alpha variants for, and which state variants (responsive, hover, etc.) to generate for each. This option behaves in the same way as the [`modules` property in the main Tailwind configuration](https://tailwindcss.com/docs/configuration#modules), with one difference: a value of `true` means "inherit from the main Tailwind `modules` configuration."

### `alpha` (optional)

This is an object containing the alpha values for your new color utilities. If this is not specified in the plugin options the `alpha` property in your main Tailwind configuration will be used. If there is no `alpha` property then the `opacity` property is used.

The keys of this object appear at the end of the utility class names. For example if you have a background color with a key of `red` and an alpha with a key of `25` then a `bg-red-25` class would be generated.

## Example

```js
module.exports = {
  // ...
  backgroundColors: {
    red: '#f00'
  },
  // ...
  plugins: [
    require('tailwindcss-alpha')({
      modules: {
        backgroundColors: []
      },
      alpha: {
        '25': 0.25,
        '50': 0.5,
        '75': 0.75
      }
    })
  ]
  // ...
}
```

The configuration above yields the following utilities:

```css
.bg-red-25 {
  background-color: rgba(255, 0, 0, 0.25);
}

.bg-red-50 {
  background-color: rgba(255, 0, 0, 0.5);
}

.bg-red-75 {
  background-color: rgba(255, 0, 0, 0.75);
}
```
npm package: @hacknug/tailwindcss-plugin-utils
Description: ![Travis (.com)](https://img.shields.io/travis/com/hacknug/tailwindcss-plugin-utils) ![David](https://img.shields.io/david/hacknug/tailwindcss-plugin-utils) ![node](https://img.shields.io/node/v/@hacknug/tailwindcss-plugin-utils) ![npm](https://img.shield
Author: Nestor Vera
Latest version: 0.8.0