open-index/open-npm huggingface dataset:
npm package: @squadette/hammerjs
Description: A javascript library for multi-touch gestures
Author: Jorik Tangelder
Latest version: 2.1.0-pre3

# Hammer.js 2.1.0-pre2

[![Build Status](https://travis-ci.org/squadette/hammer.js.svg)](https://travis-ci.org/squadette/hammer.js)

## Support, Questions, and Collaboration

[![Slack Status](https://hammerjs.herokuapp.com/badge.svg)](https://hammerjs.herokuapp.com/)

## Documentation

Visit [squadette.github.io/hammer.js](http://squadette.github.io/hammer.js) for detailed documentation.

```js
// get a reference to an element
var stage = document.getElementById('stage');

// create a manager for that element
var mc = new Hammer.Manager(stage);

// create a recognizer
var Rotate = new Hammer.Rotate();

// add the recognizer
mc.add(Rotate);

// subscribe to events
mc.on('rotate', function(e) {
    // do something cool
    var rotation = Math.round(e.rotation);    
    stage.style.transform = 'rotate('+rotation+'deg)';
});
```

An advanced demo is available here: [http://codepen.io/runspired/full/ZQBGWd/](http://codepen.io/runspired/full/ZQBGWd/)


## Contributing

Read the [contributing guidelines](./CONTRIBUTING.md).

For PRs.

- Use [Angular Style commit messages](https://github.com/angular/angular.js/blob/v1.4.8/CONTRIBUTING.md#commit)
- Rebase your PR branch when necessary
- If you add a feature or fix a bug, please add or fix any necessary tests.
- If a new feature, open a docs PR to go with.

## Building

You can get the pre-build versions from the Hammer.js website, or do this by yourself running 
`npm install -g grunt-cli && npm install && grunt build`
npm package: @squadette/react-hammerjs
Description: ReactJS / HammerJS integration. Support touch events in your React app.
Author: Jed Watson
Latest version: 1.1.0-pre3

React-HammerJS
==============

[ReactJS](http://facebook.github.io/react/) / [HammerJS](http://hammerjs.github.io) integration. Support touch events in your React app.

If you're looking for native tap event handling in ReactJS, check out my [react-tappable](https://github.com/JedWatson/react-tappable) package.


## Installation

The easiest way to use React-HammerJS is to install it from NPM and include it in your own React build process (using [Browserify](http://browserify.org), etc).

You can also use the standalone build by including `dist/hammer.js` in your page. If you use this, make sure you have already included React, and it is available as a global variable.

```
npm install react-hammerjs --save
```


## Usage

React-HammerJS wraps a React component, binding Hammer events to it so it can fire the handlers specified.

## Properties

### Event Listener properties
* `onTap`
* `onDoubleTap`
* `onPan`
* `onPanCancel`
* `onPanEnd`
* `onPanStart`
* `onPinch`
* `onPinchCancel`
* `onPinchEnd`
* `onPinchIn`
* `onPinchOut`
* `onPinchStart`
* `onPress`
* `onPressUp`
* `onRotate`
* `onRotateCancel`
* `onRotateEnd`
* `onRotateMove`
* `onRotateStart`
* `onSwipe`
* `action` - like the `onTap` event handler but will also be fired `onPress`.

### Behavior properties
* `direction` - (string) `'DIRECTION_ALL'` | `'DIRECTION_HORIZONTAL'` | `'DIRECTION_VERTICAL'`.  Used to restrict the `pan` and `swipe` direction. These string values may also work: `'DIRECTION_NONE'` |`'DIRECTION_LEFT'` | `'DIRECTION_RIGHT'` | `'DIRECTION_UP'` | `'DIRECTION_DOWN'`.

* `options` - can be used to configure the Hammer manager. These properties will be merged with the default ones.

### Example

```js
var Hammer = require('react-hammerjs');

// Default options
<Hammer onTap={handleTap} onSwipe={handleSwipe}><div>Tap Me</div></Hammer>

// Custom options
var options = {
    touchAction:'compute',
    recognizers: {
        tap: {
            time: 600,
            threshold: 100
        }
    }
};

<Hammer onTap={handleTap} options={options}><div>Tap Me</div></Hammer>
```

# Disabled Events

As a default, the `pinch` and `rotate` events are disabled in hammer.js, as they would make actions on an element "blocking". You may enable these events using the options object which is a attribute on the react `<Hammer>` element.

For example, to activate the `pinch` event on a `canvas` element:

```js
<Hammer
    onPinch={handlePinch}
    options={{
       recognizers: {
          pinch: { enable: true }
       }
    }}>
    <canvas></canvas>
</Hammer>
```

Disabled events are detailed in the hammer.js api documentation:
- http://hammerjs.github.io/recognizer-rotate/
- http://hammerjs.github.io/recognizer-pinch/

# License

MIT Licensed. Copyright (c) Jed Watson 2017.
npm package: @squadrondev/forge-publisher
Description: Squadron publisher for Electron Forge
Latest version: 0.0.3

# Squadron Electron Forge Publisher

## Usage

```js
// Within the publishers array:
{
  name: '@squadrondev/forge-publisher',
  config: {
    appId: '1',
    // See settings for the token, by default use "process.env.SQUADRON_TOKEN"
    token: process.env.SQUADRON_TOKEN,
  }
}
```
npm package: @squads-protocol/multisig
Description: SDK for Squads Multisig Program v4
Latest version: 2.1.2

# @sqds/multisig

This is the package for the Squads v4 Typescript SDK.

<a href="https://docs.squads.so/main/v/development">Docs</a>
•
<a href="https://www.npmjs.com/package/@sqds/multisig">NPM</a>

## Installation

Add the SDK to your project with npm:
```
npm i @sqds/multisig
```

or yarn:
```
yarn add @sqds/multisig
```

## Get Started

First, get the multisig account address:
```typescript
import * as multisig from "@sqds/multisig";

const {
    Multisig
} = multisig.accounts;

const [multisigPda] = multisig.getMultisigPda({
    createKey,
});

/// or define it directly
const multisigPda = new PublicKey("<multisig key>");
```

Then get the multisig account info:
```typescript
const multisigAccount = await Multisig.fromAccountAddress(
    connection,
    multisigPda
);
// Log out the multisig's members
console.log("Members", multisigAccount.members);
```

Once you fetch your multisig, fetch the vault account:
```typescript
const [vaultPda] = multisig.getVaultPda({
    multisigPda,
    index: 0,
});
```

From here, you can create your first vault transaction:
```typescript
const transactionIndex = 1n;

const transferInstruction = SystemProgram.transfer(
    // The transfer is being signed from the Squads Vault, that is why we use the VaultPda
    vaultPda,
    to.publicKey,
    1 * LAMPORTS_PER_SOL
);

// Here we are adding all the instructions that we want to be executed in our transaction
const testTransferMessage = new TransactionMessage({
    payerKey: vaultPda,
    recentBlockhash: (await connection.getLatestBlockhash()).blockhash,
    instructions: [transferInstruction],
});

await multisig.rpc.vaultTransactionCreate({
    connection,
    feePayer,
    multisigPda,
    transactionIndex,
    creator: feePayer.publicKey,
    vaultIndex: 0,
    ephemeralSigners: 0,
    transactionMessage: testTransferMessage,
});
```

Check our <a href="https://docs.squads.so/main/v/development">documentation</a> for more information on instruction types and ancillary features.
npm package: @squads-ventures/metrics-service
Description: SDK for the Metrics Service
Author: SquadS Ventures
Latest version: 0.0.7

# metrics-service-sdk

To install dependencies:

```bash
bun install
```

To run:

```bash
bun run index.ts
```

This project was created using `bun init` in bun v1.1.21. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.
npm package: @squadswap/v3-core
Description: 🥞 Core smart contracts of SquadSwap V3
Latest version: 1.0.7

# SquadSwap V3

This repository contains the core smart contracts for the SquadSwap V3 Protocol.
For higher level contracts, see the [v3-periphery](../v3-periphery/)
repository.

## Local deployment

In order to deploy this code to a local testnet, you should install the npm package
`@squadswap/v3-core`
and import the factory bytecode located at
`@squadswap/v3-core/artifacts/contracts/SquadV3Factory.sol/SquadV3Factory.json`.
For example:

```typescript
import {
  abi as FACTORY_ABI,
  bytecode as FACTORY_BYTECODE,
} from '@squadswap/v3-core/artifacts/contracts/SquadV3Factory.sol/SquadV3Factory.json'

// deploy the bytecode
```

This will ensure that you are testing against the same bytecode that is deployed to
mainnet and public testnets, and all SquadSwap code will correctly interoperate with
your local deployment.

## Using solidity interfaces

The SquadSwap v3 interfaces are available for import into solidity smart contracts
via the npm artifact `@squadswap/v3-core`, e.g.:

```solidity
import '@squadswap/v3-core/contracts/interfaces/ISquadV3Pool.sol';

contract MyContract {
  ISquadV3Pool pool;

  function doSomethingWithPool() {
    // pool.swap(...);
  }
}

```
npm package: @squadswap/v3-lm-pool
Description: Liquidity Mining Pool (LM Pool) is a separate contract for liquidity mining reward accounting. It is not meant to be deployed manually. It will be deployed automatically by MasterChefV3 with LmPoolDeployer whenever there is a new liquidity mining campaign
Latest version: 1.0.2

# v3-lm-pool

Liquidity Mining Pool (LM Pool) is a separate contract for liquidity mining
reward accounting.
It is not meant to be deployed manually.
It will be deployed automatically by MasterChefV3 with LmPoolDeployer whenever
there is a new liquidity mining campaign.
As for testing, please check the tests in MasterChefV3 which is the main testing
entry point to test the correctness of the reward calculation.