open-index/open-npm huggingface dataset:
npm package: @palettebro/theme-toolbar
Description: A React component library for managing and customizing color palettes in your application.
Latest version: 0.2.0

# @palettebro/theme-toolbar

A React component library for managing and customizing color palettes in your application.

## Features

- Dynamic and static color palette generation
- WCAG 2.2 and 3.0 contrast grade checking
- Color swatch management with lock/unlock functionality
- Light/dark mode toggle
- Favorites system for saving color combinations
- Customizable presets and profiles
- Responsive design with mobile support

## Installation

```bash
pnpm add @palettebro/theme-toolbar
```

## Usage

```tsx
import { PaletteProvider, PaletteToolbar, GenerativePaletteContextProvider } from '@palettebro/theme-toolbar';

function App() {
  return (
    <PaletteProvider themes={themes}>
      <GenerativePaletteContextProvider>
        <PaletteToolbar
          FormComponent={FormComponent}
          useFetcher={useFetcher}
          generateEndpoint="/generate"
          favouritesEndpoint="/favourites"
        />
      </GenerativePaletteContextProvider>
    </PaletteProvider>
  );
}
```

## Components

### PaletteProvider

Provides theme context to the application.

```tsx
<PaletteProvider themes={themes} lightOrDark="light">
  {children}
</PaletteProvider>
```

### PaletteToolbar

The main toolbar component for managing colors.

```tsx
<PaletteToolbar
  FormComponent={FormComponent}
  useFetcher={useFetcher}
  generateEndpoint="/generate"
  favouritesEndpoint="/favourites"
/>
```

## Color Tokens

### Base Tokens
- primary
- secondary
- accent

### Status Tokens
- info
- success
- warning
- error

## Features

### Static Palette Generation
- Split Complementary
- Tetrad
- Triad
- Reverse option

### Dynamic Palette Generation
Presets:
- Default
- High Contrast
- Bright Light
- Pastel
- Vibrant
- Dark
- Hyper Color

Targets:
- Website Magazine
- Brand 2
- Brand 3
- Website 1

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

MIT
npm package: @palettegear/serialport-binding-abstract
Description: This Abstract binding class is the base for all serialport bindings. You wouldn't use this class directly but instead extend it to make a new binding for a different platform or underling technology.
Latest version: 2.0.6

# @serialport/BindingAbstract

This Abstract binding class is the base for all serialport bindings. You wouldn't use this class directly but instead extend it to make a new binding for a different platform or underling technology.

This is currently used for the win32, linux, darwin and mock bindings.

This is how you use it.
```js
class MockBinding extends AbstractBinding {
  constructor(opt) {
    super(opt)
  }
}
```
npm package: @palettegear/serialport-bindings
Description: The `Binding` is how Node-SerialPort talks to the underlying system. By default, we auto detect Windows, Linux and OS X, and load the appropriate module for your system. You can assign `SerialPort.Binding` to any binding you like. Find more by searching [
Latest version: 2.0.9

# @serialport/Bindings

The `Binding` is how Node-SerialPort talks to the underlying system. By default, we auto detect Windows, Linux and OS X, and load the appropriate module for your system. You can assign `SerialPort.Binding` to any binding you like. Find more by searching ["serialport-binding" at npm](https://www.npmjs.com/search?q=serialport-binding).

Learn more at our [bindings documentation](https://serialport.io/docs/api-bindings) page.
npm package: @palettegear/serialport-list
Description: ```bash $ npx @serialport/list [options] # or $ npm install -g @serialport/list $ serialport-list [options] ```
Latest version: 1.3.0

## SerialPort List

```bash
$ npx @serialport/list [options]
# or
$ npm install -g @serialport/list
$ serialport-list [options]
```

The package `@serialport/list` will install the `serialport-list` cli tool which lists all available serial ports in different formats.

```bash
$ serialport-list -h

  Usage: serialport-list [options]

  List available serial ports

  Options:

    -h, --help           output usage information
    -V, --version        output the version number
    -f, --format <type>  Format the output as text, json, or jsonline. default: text


$ serialport-list
/dev/tty.Bluetooth-Incoming-Port
/dev/tty.usbmodem1421    Arduino (www.arduino.cc)

$ serialport-list -f json
[{"comName":"/dev/tty.Bluetooth-Incoming-Port"},{"comName":"/dev/tty.usbmodem1421","manufacturer":"Arduino (www.arduino.cc)","serialNumber":"752303138333518011C1","locationId":"14200000","vendorId":"2341","productId":"0043"}]

$ serialport-list -f jsonline
{"comName":"/dev/tty.Bluetooth-Incoming-Port"}
{"comName":"/dev/tty.usbmodem1421","manufacturer":"Arduino (www.arduino.cc)","serialNumber":"752303138333518011C1","locationId":"14200000","vendorId":"2341","productId":"0043"}
```
npm package: @palettegear/serialport-repl
Description: ```bash $ npx @serialport/repl <port> # or $ npm install -g @serialport/repl $ serialport-repl <port> ```
Latest version: 1.3.0

## SerialPort Repl
```bash
$ npx @serialport/repl <port>
# or
$ npm install -g @serialport/repl
$ serialport-repl <port>
```

The package `@serialport/repl` will install the `serialport-repl` cli tool which provides a nodejs repl for working with serialport. This is valuable when debugging.

You can make use of the `serialport-repl` command with;
```bash
$ serialport-repl # to auto detect an arduino
$ serialport-repl /dev/tty.usbmodem1421 # to connect to a specific port
```

It will load a serialport object with debugging turned on.
```bash
$ serialport-repl
  serialport:binding:auto-detect loading DarwinBinding +0ms
port = SerialPort("/dev/tty.usbmodem1421", { autoOpen: false })
globals { SerialPort, portName, port }
> SerialPort.list()
  serialport:main .list +6s
[ { comName: '/dev/tty.usbmodem1421',
    manufacturer: 'Arduino (www.arduino.cc)',
    serialNumber: '752303138333518011C1',
    pnpId: undefined,
    locationId: '14200000',
    vendorId: '2341',
    productId: '0043' } ]
> port.write('Calling all Autobots!')
true
> port.read()
  serialport:main _read queueing _read for after open +1m
null
> port.open()
  serialport:main opening path: /dev/tty.usbmodem1421 +30s
  serialport:bindings open +1ms
```
npm package: @palettegear/serialport-stream
Description: The serialport stream interface. This package requires bindings to work.
Latest version: 2.0.6

# @serialport/Stream

The serialport stream interface. This package requires bindings to work.

You'd use this if you want to keep your package size down by requiring only the parts of serialport that you want to use. It is used internally in the `serialport` package.

This is how you use it.
```js

const SerialPort = require('@serialport/stream')
const Binding = require('@serialport/bindings')
SerialPort.Binding = Binding
const port = new Serialport('/dev/ttyay')
```
npm package: @palettegear/serialport-terminal
Description: ```bash $ npx @serialport/terminal  -p <port> [options] # or $ npm install -g @serialport/terminal $ serialport-terminal  -p <port> [options] ```
Latest version: 1.3.0

## SerialPort Terminal
```bash
$ npx @serialport/terminal  -p <port> [options]
# or
$ npm install -g @serialport/terminal
$ serialport-terminal  -p <port> [options]
```

The package `@serialport/terminal` will install the `serialport-terminal` cli tool which provides a basic terminal interface for communicating over a serial port. `ctrl+c` will exit.

```bash
$ serialport-terminal -h

  Usage: serialport-terminal -p <port> [options]

  A basic terminal interface for communicating over a serial port. Pressing ctrl+c exits.

  Options:

    -h, --help                     output usage information
    -V, --version                  output the version number
    -l --list                      List available ports then exit
    -p, --port, --portname <port>  Path or name of serial port
    -b, --baud <baudrate>          Baud rate default: 9600
    --databits <databits>          Data bits default: 8
    --parity <parity>              Parity default: none
    --stopbits <bits>              Stop bits default: 1
    --echo --localecho             Print characters as you type them

$ serialport-terminal -l
/dev/tty.Bluetooth-Incoming-Port
/dev/tty.usbmodem1421    Arduino (www.arduino.cc)
```
npm package: @palharez/react-native-qrcode
Description: react-native qrocode generator
Author: sivision.chen
Latest version: 0.2.8

# react-native-qrcode
A react-native component to generate [QRcode](http://en.wikipedia.org/wiki/QR_code), not only support English.

## Installation
```sh
npm install react-native-qrcode --save
```
## Usage
```jsx
'use strict';

import React, { Component } from 'react'
import QRCode from 'react-native-qrcode';

import {
    AppRegistry,
    StyleSheet,
    View,
    TextInput
} from 'react-native';

class HelloWorld extends Component {
  state = {
    text: 'http://facebook.github.io/react-native/',
  };

  render() {
    return (
      <View style={styles.container}>
        <TextInput
          style={styles.input}
          onChangeText={(text) => this.setState({text: text})}
          value={this.state.text}
        />
        <QRCode
          value={this.state.text}
          size={200}
          bgColor='purple'
          fgColor='white'/>
      </View>
    );
  };
}

const styles = StyleSheet.create({
    container: {
        flex: 1,
        backgroundColor: 'white',
        alignItems: 'center',
        justifyContent: 'center'
    },

    input: {
        height: 40,
        borderColor: 'gray',
        borderWidth: 1,
        margin: 10,
        borderRadius: 5,
        padding: 5,
    }
});

AppRegistry.registerComponent('HelloWorld', () => HelloWorld);

module.exports = HelloWorld;
```
## Available Props

prop      | type                 | default value
----------|----------------------|--------------
`value`   | `string`             | `http://facebook.github.io/react-native/`
`size`    | `number`             | `128`
`bgColor` | `string` (CSS color) | `"#000"`
`fgColor` | `string` (CSS color) | `"#FFF"`

<img src='qrcode.png' height = '256' width = '256'/>

# Licenses

All source code is licensed under the [MIT License](https://github.com/cssivision/react-native-qrcode/blob/master/LICENSE).
npm package: @palhari/nq
Description: ⚡️ Batteries included JSON mapper
Author: Pedro Palhari
Latest version: 1.0.5

# ⚡️ nq

`nq` is a batteries included tool to map JSON!

- **TIP:** for best usage and autocomplete, make sure VSCode is accessible through `code` on your bash.

# 🎥 Preview

![image info](./assets/preview.gif)

# 📝 Examples

- Installing globally

```bash
npm i -g @palhari/nq

echo '{ "users": [{ "name": "pedro" }, { "name": "palhari" }]}' | nq

# or also
nq <file>
```

- Using `npx`

```bash
echo '{ "users": [{ "name": "pedro" }, { "name": "palhari" }]}' | npx @palhari/nq

# or also
npx @palhari/nq <file>
```

# 🤔 How to use it

- You invoke `nq` on a JSON of choice.
- A VSCode window appears with a default exported function.
- The function has a parameter, `json`. The parameter has autocomplete from the input JSON.
- Close the VSCode tab, the function runs.

# ⚙️ Options

- `-n`, open in a new VSCode instance

# 🧠 Motivation

I'm a very big fan of `jq`. Unfortunately, I'm as much equally dumb to use it.

I really *really* like autocompletion. Besides strict typechecking it's a must, specially in small scripts you're tinkering with. Making sense of data needs to be visual and comprehensible. 

My aim is to bring a little bit of that here.

# Acknowledgments

There are two big main libraries that this project heavily depends on, [tsm]() and [json-to-ts](). `tsm` is used to provide the runtime with a fast transpiler for the typescript function and `json-to-ts` is used to generate types from the input JSON. Be sure to check them out as they're really powerful on their own.

Also, [nanoid]() is used for the file names.
npm package: @paliari/vue-test-utils
Description: JS test utils
Author: Felipe Bohnert Paetzold
Latest version: 0.0.13

# vue-test-utils

#Install
- Use npm
    
    ```$ npm install -D @paliari/vue-test-utils --save```
- Use yarn

    ```$ yarn add -D @paliari/vue-test-utils```

## Mocks
#### StoreHelpers

With this it is possible to mock the paliari vue store helper methods (base, paginator, crud)
    
Usage sample:
```javascript
import '@paliari/vue-test-utils/__mocks__/StoreHelpers'
import paliariVue from 'paliari-vue'
import 'store/modules/anyStore'
import api from './__mocks__/api'

const { StoreHelpers } = paliariVue

it('should to call the auxiliary store with the correct parameters', () => {
    expect(StoreHelper.base).toBeCalledTimes(1)
    expect(StoreHelper.base).toBeCalledWith({ namespaced: true }, api)
})
```

---

#### Filters

Mocks of the main filters used in the projects
    
Usage sample:
```javascript
import { shallowMount } from '@vue/test-utils'
import { filters } from '@paliari/vue-test-utils'
import Component from '@/views/Zubumafu.vue'

describe('renderer', () => {
    it('should matched snapshot', () => {
        const wrapper = shallowMount(Component, { filters })
        expect(wrapper.element).toMatchSnapshot()
    })
    it('should to call filter cpfCnpj', () => {
        expect(filters.cpfCnpj).toBeCalledTimes(1)
        expect(filters.cpfCnpj).toBeCalledWith('00000000000')
    })
})
```
    
Single imports sample:
```javascript
import { cpfCnpj, truncate, date } from '@paliari/vue-test-utils/__mocks__/filters'
```
    
Available filters
    
|  name    | params                              | returns                             |
|----------|-------------------------------------|-------------------------------------|
| cpfCnpj  |   (value)                           |    v                                |
| currency |   (number, prefix = '', sufix = '') |   `${prefix}${number}${sufix}`      |
|  date    |  (value, format)                    |    value                            |
| truncate |  (text, length = 30)                |`text.substr(0, length - 3) + '...'` |