open-index/open-npm huggingface dataset:
npm package: @pmochine/vee-validate-laravel
Description: Adds simple laravel form validation support to vee-validate
Author: Philipp Mochine
Latest version: 1.0.6

# 🙌 VeeValidate with Laravel validation errors
[![Latest Version on NPM](https://img.shields.io/npm/v/%40pmochine%2Fvee-validate-laravel.svg?style=flat-square)](https://npmjs.com/package/%40pmochine%2Fvee-validate-laravel)
[![Total Downloads on NPM](https://img.shields.io/npm/dt/%40pmochine%2Fvee-validate-laravel.svg)](https://www.npmjs.com/package/%40pmochine%2Fvee-validate-laravel)
[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE.md)

![VeeValidate with Laravel validation](https://baianat.github.io/vee-validate/logo.png)

**If you are looking for an easy module for showing Laravel validation errors, this package is for you. 😜**

>***Prerequisites**:  vue >= 2.0.0 and vee-validate >= 2.1.0

*⚠️ Combine this package with a [global axios interceptor](https://github.com/pmochine/vue-axios-interceptors) to get the most of it*

## Installation in 2 Steps*

### 1: Install the package 💻 on [NPM](https://www.npmjs.com/package/@pmochine/vee-validate-laravel)
```bash
npm i @pmochine/vee-validate-laravel
```
### 2: Add the package in your main.js

```javascript
import Vue from 'vue';
import VeeValidate from 'vee-validate';
import VeeValidateLaravel from '@pmochine/vee-validate-laravel';

Vue.use(VeeValidate);
Vue.use(VeeValidateLaravel);
```


## 💪 How to use it

Somewhere in Laravel:

```php
$request->validate([
    'name' => 'required|min:3|max:255'
]);

```


Somewhere in Vue:


```vue
<template>
    <div class="form-group" v-bind:class="{'has-error' : errors.has('name')}">
        <label for="name">Name</label>
        <input 
            type="text" 
            name="name"
            class="form-control"
            v-model="name"
            v-validate="'required'" />
        <div v-show="errors.has('name')" class="help-block">{{ errors.first('name') }}</div>
    </div>
</template>

<script>
    export default {
        methods: {
            doValidation() {
                const data = {
                    name: this.name
                };
            
                axios.post('/example', data)
                    .then(res => {})
                    .catch(err => {
                        //adds errors to vee-validate errorBag and returns the errors as object
                        const errors = this.$addLaravelErrors(err.response);

                        if(errors){
                            alert(errors[Object.keys(errors)[0]]); 
                        }
                    });
            }
        }
    }
</script>
```

## Security

If you discover any security related issues, please don't email me. I'm afraid 😱. avidofood@protonmail.com

## Credits

Now comes the best part! 😍

 - Idea found on https://github.com/RobertGlynWilliams/vee-validate-laravel

Oh come on. You read everything?? If you liked it so far, hit the ⭐️ button to give me a 🤩 face.
npm package: @pmoo/oow
Description: Extension methods that should exist in JS core by default
Author: Nahuel Garbezza
Latest version: 1.11.0

# OOW

An "Object-Oriented way" for JS (methods that should exist by default). The idea is to add more OO
experience, especially suited for teaching OOP. **Not intended for production usage.**

## Installation

`npm install @pmoo/oow`

(required Node version: 8.x or higher)

## Extensions

To see all the available extensions, please have a look at the tests inside the `test` folder.

### Collections

`Array`, `String` and `Set` are classes that have very few methods in common, even though
they are all collections. For instance, `Set` has `size` and Array has `length`. So this
library defines some common behavior to make sure we can have more polymorphism.

Most of the added message names are inspired by Smalltalk (`isEmpty`, `includesAllOf`, `at`)
and Ruby (`take`, `drop`, `compact`).

#### Polymorphism achieved so far

Among many of the messages added to the collection protocols, these are the messages that some collections have by default but others don't:

* `add(obj)` works for `Array` and `Set` (we added the `Array` version)
* `includes(obj)` works for `Array` and `Set` (we added the `Set` version)
* `filter(condition)` works for every collection (we added the `String` and `Set` versions)
* `reverse()` works for `Array` and `String` (we added the `String` version)

### `Date`

Working with `Date` is not so easy so there're also helper methods like `monthNumber` that
returns a number from 1 to 12.

## New Objects

### `Point`

`Point` class represents an (x, y) pair. You can access its parts by sending `x()` and `y()` messages.

### `DayOfMonth`

`DayOfMonth` represents a day in a month, not specific to a year, like "November 9th". The `day()` and `monthNumber()` messages can be used to access the information.
npm package: @pmouli/homebridge-mylink
Description: Somfy myLink plugin for Homebridge.
Author: Timothy Yung
Latest version: 1.5.1-beta.52

# homebridge-mylink

Somfy myLink plugin for [Homebridge](https://github.com/nfarina/homebridge)

This plugin makes use of the [node-somfy-synergy](https://github.com/yungsters/node-somfy-synergy) package.

# Configuration

```json
{
  "platform": "Somfy myLink",
  "ipAddress": "192.168.1.123",
  "systemID": "mySystem",
  "targets": [
    {
      "targetID": "AB123C45.1",
      "name": "Family Room Window"
    },
    {
      "targetID": "AB123C45.2",
      "name": "Dining Room Window"
    },
    {
      "targetID": "AB123C45.4",
      "name": "Master Bedroom Window",
      "orientation": {
        "closed": "stop",
        "middle": "down",
        "opened": "up"
      }
    }
  ]
}
```

# Setup

You will need to use the Somfy myLink mobile app to configure the System ID and find the IP address and Target IDs. 

* Go to "Integration", choose one of the options that isn't Alexa or IFTTT, then choose "Change System ID"
* With a System ID set, choose "Get Integration report"
npm package: @pmouli/somfy-synergy
Description: Interface for the Somfy Synergy API (myLink).
Author: Timothy Yung
Latest version: 1.5.0-beta.34

# node-somfy-synergy

A JavaScript interface for the Somfy Synergy API (myLink).

This package was tested using a [Somfy myLink (Rev 2.0)](https://www.somfysystems.com/products/controls/mylink). To find out if your Somfy myLink is Rev 2.0, check out "What is different with the newer myLink (Rev 2.0)?" on the [Somfy myLink FAQ](https://www.somfysystems.com/products/controls/mylink/faq).

## Setup

You will need to use the Somfy myLink mobile app in order to configure your System ID, to obtain your Somfy myLink's IP address, and to obtain the Target IDs for each remotely controlled device.

* Go to "Integration" and set a System ID by tapping "Change System ID" (which can be any string).
* Tap "Get Integration report" to view the System ID, IP address, and Target IDs.

## Example

The `SomfySynergy` class is instantiated with the System ID and IP address of your Somfy myLink.

The `SomfySynergy` class allows you to send the "down", "stop", and "up" commands to each target device.

```js
const synergy = new SomfySynergy('mySystem', '192.168.1.123');

// Open the first set of shades.
const target1 = synergy.target('AB123C45.1');
target1.up();

// Close the second set of shades.
const target2 = synergy.target('AB123C45.2');
target2.down();

// Stop (or go to the favorite position for) the third set of shades.
const target3 = synergy.target('AB123C45.2');
target3.stop();
```

Each command is asynchronous (i.e. returns a promise):

```js
synergy
  .target('AB123C45.1')
  .up()
  .then(success => {
    if (success) {
      console.log('Opened the first set of shades!');
    } else {
      console.error('Failed to open the first set of shades.');
    }
  });
```

## Composite Targeting

The `SomfySynergy.Platform` class exposes an interface similar to `SomfySynergy`. Unlike `SomfySynergy`, this class will efficiently batch requests into "composite targets".

For example, suppose you have three Somfy myLink targets:

* Target A: Left Window Shade
* Target B: Right Window Shade
* Target C: Both Window Shades

In other words, Target C is a channel programmed to control both Target A and Target B. You could then instantiate `SomfySynergy.Platform` with:

```js
const platform = new SomfySynergy.Platform(
  new SomfySynergy(...),
  {
    '<Target A>': [],
    '<Target B>': [],
    '<Target C>': ['<Target A>', '<Target B>'],
  }
);
```

Unlike with `SomfySynergy`, sending the same command to multiple targets that are part of the same composite target will lead to de-duplication:

```js
platform.target('<Target A>').up();
platform.target('<Target B>').up();
// Equivalent to...
platform.target('<Target C>').up();
```

This is useful for implementing more synchronized control of targets, whereas Somfy myLink typically incurs a short delay in between each method.

### License

node-somfy-synergy is [MIT licensed](./LICENSE).
npm package: @pmpl/poorvika-components
Description: A React component library for Poorvika e-commerce app
Author: Nithyaduruvan
Latest version: 1.0.2

# Poorvika Components Library

This project was created as a React component library for Poorvika e-commerce app using:

- [React](https://reactjs.org/)
- [TypeScript](https://www.typescriptlang.org/)
- [Rollup](https://github.com/rollup/rollup)

It also features:

- [Storybook](https://storybook.js.org/) to help you create and show off your components
- [Jest](https://jestjs.io/) and [React Testing Library](https://github.com/testing-library/react-testing-library) enabling testing of the components

## Development

### Testing

```
npm run test
```

### Building

```
npm run build
```

### Storybook

To run a live-reload Storybook server on your local machine:

```
npm run storybook
```

To export your Storybook as static files:

```
npm run storybook:export
```

You can then serve the files under `storybook-static` using S3, GitHub pages, Express etc.

### Generating New Components

I've included a handy NodeJS util file under `util` called `create-component.js`. Instead of copy pasting components to create a new component, you can instead run this command to generate all the files you need to start building out a new component. To use it:

```
npm run generate YourComponentName
```

This will generate:

```
/src
  /YourComponentName
    YourComponentName.tsx
    YourComponentName.stories.tsx
    YourComponentName.test.tsx
    YourComponentName.types.ts
    YourComponentName.css
    index.ts
```

The default templates for each file can be modified under `util/templates`.

Don't forget to add the component to your `src/index.ts` exports if you want the library to export the component!

### Installing Component Library Locally

Let's say you have another project (`poorvika-web`) on your machine that you want to try installing the component library into without having to first publish the component library. In the `poorvika-web` directory, you can run:

```
npm i --save ../poorvika-components
```

which will install the local component library as a dependency in `poorvika-web`. It'll then appear as a dependency in `package.json` like:

```JSON
  ...
  "dependencies": {
    ...
    "poorvika-components": "file:../poorvika-components",
    ...
  },
  ...
```

Your components can then be imported and used in that project.

## Publishing

### Hosting via GitLab

Build the component library (`npm run build`), add, commit and push the contents including `build` folder.

You can then install your library into other projects by running:

```
npm i --save git+https://gitlab.com/just-arun/poorvika-components.git#<branch-name>

```

## Usage

Let's say you created a component called `TestComponent` in this repository.

Usage of the component (after the library installed as a dependency into another project) will be:

```TSX
import React from "react";
import { TestComponent } from "poorvika-components";

const App = () => (
  <div className="app-container">
    <h1>Hello I'm consuming the component library</h1>
    <TestComponent theme="primary" />
  </div>
);

export default App;
```