open-index/open-npm huggingface dataset:
npm package: @pint3swap/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 camp
Latest version: 1.0.0

# 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.
npm package: @pinta-ai/types
Description: Shared type definitions for Pinta AI adapters and log processing server
Latest version: 0.0.4

# @pinta-ai/types

Single source of truth for shared type definitions across the Pinta platform.

Defines the data structures exchanged between adapters (mcp-logger, etc.) and the backend (aware-backend).

## Install

```bash
npm install @pinta-ai/types
```

## Usage

```typescript
import type { IngestTypeMap, IngestType, MCPSpan } from '@pinta-ai/types';
```

## Core Types

| Type | Description |
|------|-------------|
| `IngestTypeMap` | Maps `ingest.type` values to span attribute interfaces |
| `IngestType` | Union of supported ingest types (`'mcp' \| ...`) |
| `MCPSpan` | Span attribute interface for the MCP adapter |

## Adding a New Adapter

1. Define a span attribute interface in `src/ingest.ts` (e.g., `PintaclawSpan`)
2. Add mapping to `IngestTypeMap` (e.g., `pintaclaw: PintaclawSpan`)
3. Export from `src/index.ts`

## Conventions

- Flat key-value structure only (serialized as OTel span attributes)
- Value types: `string | number | boolean | undefined`
- Every span interface must include an `ingest.type` field (discriminator)

## License

[MIT](LICENSE)
npm package: @pinta365/blizzard_api
Description: TS library to interact with the Blizzard Battle.net API. World of Warcraft, World of Warcraft Classic, StarCraft 2, Diablo 3, Hearthstone.
Author: Pinta
Latest version: 0.4.0

# BLIZZARD API

[![JSR Version](https://jsr.io/badges/@pinta365/blizzard-api)](https://jsr.io/@pinta365/blizzard-api)

Start of what will cover the whole Blizzard Battle.net API when its done.

Available as:

- ESM module: [JSR](https://jsr.io/@pinta365/blizzard-api)
- CommonJS module: [NPM](https://www.npmjs.com/package/@pinta365/blizzard_api)

## WORK IN PROGRESS

Let me know if you want certain APIs to be prioritized. Currently only supports client credentials flow but the plan is
to implement authorization code flow also.

### APIs implemented

| APIs                                          | Status | Note                      |
| --------------------------------------------- | ------ | ------------------------- |
| **World of Warcraft:** Game Data APIs         | ✅     |                           |
| **World of Warcraft:** Profile APIs           | ✅     |                           |
|                                               |        |                           |
| **World of Warcraft Classic:** Game Data APIs |        |                           |
| **World of Warcraft Classic:** Profile APIs   |        |                           |
|                                               |        |                           |
| **Diablo III:** Community APIs                | ✅     | Missing profile endpoints |
| **Diablo III:** Game Data APIs                | ✅     |                           |
|                                               |        |                           |
| **Hearthstone:** Game Data APIs               | ✅     |                           |
|                                               |        |                           |
| **StarCraft II:** Community APIs              |        |                           |
| **StarCraft II:** Game Data APIs              | ✅     |                           |

## ⚡️ Quickstart

**Installation**

```bash
# Deno
deno add @pinta365/blizzard-api

# Bun
bunx jsr add @pinta365/blizzard-api

# Node.js
npx jsr add @pinta365/blizzard-api

# NPM (CommonJS)
npm install @pinta365/blizzard_api --save
```

**Basic Usage (ESM)**

```javascript
import * as blizzardAPI from "@pinta365/blizzard-api";

const clientId = "<YOUR CLIENT ID>";
const clientSecret = "<YOUR SECRET>";

blizzardAPI.setup({
    clientId,
    clientSecret,
    region: "eu",
    locale: "en_GB",
});

const sword = await blizzardAPI.wow.item(33791);
console.log(sword);
```

**Basic Usage (CommonJS)**

```javascript
const blizzardAPI = require("@pinta365/blizzard_api");

// Use blizzardAPI the same way as in the previous example.
```

## Issues

Issues or questions concerning the library can be raised at the
[github repository](https://github.com/Pinta365/blizzard_api/issues) page.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
npm package: @pintado/realm-connect
Description: Utility library to connect to Realm Apps and query MongoDb Atlas
Author: Enguerrand Gave
Latest version: 0.8.1

# Pintado realm-connect library

This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 10.2.4.

## Code scaffolding

Run `ng generate component component-name --project realm-connect` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project realm-connect`.
> Note: Don't forget to add `--project realm-connect` or else it will be added to the default project in your `angular.json` file. 

## Build

Run `ng build realm-connect` to build the project. The build artifacts will be stored in the `dist/` directory.

## Publishing

After building your library with `ng build realm-connect`, go to the dist folder `cd dist/@pintado/realm-connect` and run `npm publish`.

## Running unit tests

Run `ng test realm-connect` to execute the unit tests via [Karma](https://karma-runner.github.io).

## Further help

To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.
npm package: @pintawebware/grunt-squeezeimg
Description: Plugin grunt
Author: pintawebware
Latest version: 1.0.4

# squeezeimg grunt

The Grunt Squeezeimg plugin is destined to optimize unlimited images without any visible loss in quality.

Using the plugin Grunt Squeezeimg you can easily minify the size of all your images, speed up loading of your websites and applications.

You can compress your images of such formats - .png, .jpg/.jpeg, .gif, .svg, .bmp, .tiff.

Also plugin allows you to convert your images to webP and jp2 format.

Try the plugin functions right now. To do this, go to https://squeezeimg.com/.

## Install

```sh
$ npm install --save-dev @pintawebware/grunt-squeezeimg
```

## Usage

 Gruntfile.js 
```js

module.exports = function (grunt) {
    grunt.initConfig({
    squeezeimg: {
        taskName: {
            options: {
                token: 'Your API token',
                qlt: 60,
                method: 'compress',
                to: 'webp',
                rename: true
                },
            src: 'images/*',
            dest: 'dest/'
            }
      }
    });
    grunt.loadNpmTasks('@pintawebware/grunt-squeezeimg');
    grunt.registerTask('default', ['squeezeimg']);
  };

```

## API

### squeezeimg(option)

#### Options
### token : 
 'Your API token', https://squeezeimg.com/account/api  or https://squeezeimg.com-> My account-> Api
### qlt :
 Quality precentage (max 80), default 60
### method : 
'convert or compress', default 'compress'
### to
convert to format ( jp2, webp, avif ) default 'webp'
### rename 
rename image, default false ( If true, the file name is assigned by the server )


### License MIT License (c) PintaWebware
npm package: @pintawebware/gulp-squeezeimg
Description: Plugins squeezeimg.com 
Author: pintawebware
Latest version: 1.0.7

# squeezeimg gulp

The Gulp Squeezeimg plugin is destined to optimize unlimited images without any visible loss in quality.

Using the plugin Gulp Squeezeimg you can easily minify the size of all your images, speed up loading of your websites and applications.

You can compress your images of such formats - .png, .jpg/.jpeg, .gif, .svg, .bmp, .tiff.

Also plugin allows you to convert your images to webP and jp2 format.

Try the plugin functions right now. To do this, go to https://squeezeimg.com/.

## Install
```sh
$ npm install --save-dev @pintawebware/gulp-squeezeimg
```

## Usage
 gulpfile.js 
```js
var squeezeimg = require('@pintawebware/gulp-squeezeimg');

const option = {
    token: 'Your API token',
    qlt: 60,
    method: 'compress',
    to: 'webp',
    rename: false,
  }

gulp.task('gulp-squeezeimg', function() {
  return gulp.src('images/*') 
    .pipe(squeezeimg(option))
    .pipe(gulp.dest('dist/'));
});

gulp.task('default', gulp.series('gulp-squeezeimg'));
```

## API

### squeezeimg(option)

#### Options Object
### token : 
 'Your API token', https://squeezeimg.com/account/api  or https://squeezeimg.com-> My account-> Api
### qlt :
 Quality precentage (max 80), default 60
### method : 
'convert or compress', default 'compress'
### to
convert to format ( jp2, webp, avif ) default 'webp'
### rename 
rename image, default false  ( If true, the file name is assigned by the server )


### License MIT License (c) PintaWebware
npm package: @pintawebware/webpack-squeezeimg
Description: Plugin squeezeimg webpack
Author: pintawebware
Latest version: 1.0.6

# squeezeimg webpack

The Webpack Squeezeimg plugin is destined to optimize unlimited images without any visible loss in quality.


Using the Webpack Squeezeimg plugin you can easily minify the size of all your images, speed up loading of your websites and applications.


You can compress your images of such formats - .png, .jpg/.jpeg, .gif, .svg, .bmp, .tiff.


Also plugin allows you to convert your images to webP and jp2 format.


Try the plugin functions right now. To do this, go to https://squeezeimg.com/.

## Install

```sh
$ npm install --save-dev @pintawebware/webpack-squeezeimg
```


## Usage
 
```js
const SqueezeimgPlugin = require("@pintawebware/webpack-squeezeimg");

module.exports = {
    plugins: [new SqueezeimgPlugin({
        src: 'images/',
        dest: 'tmp/',
        token: 'Your API token',
        qlt: 60,
        method: 'convert',
        to: 'webp',
        rename: true,
    })]
};
```

## API

### squeezeimg(option)

#### Options Object
### src 
 Path to the directory with images from the project directory.  
### dest 
 Target directory path from project directory. 
### token : 
 'Your API token', https://squeezeimg.com/account/api  or https://squeezeimg.com-> My account-> Api
### qlt :
 Quality precentage (max 80), default 60
### method : 
 Method selection convert or compress', default 'compress'
### to
convert to format ( jp2, webp, avif ) default 'webp'
### rename 
rename image, default false  ( If true, the file name is assigned by the server )

### License MIT License (c) PintaWebware
npm package: @pintob/bind-selectors
Description: Colocate selectors without coupling them to the Store state shape
Author: Bruno Pinto
Latest version: 1.0.0
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# Bind Selectors

It's a good pattern in Redux to use _selectors_. Amongst other benefits, it keeps the Store shape decoupled from its consumers (e.g. the Components), which in turn helps to have a normalized state shape and change the state without affecting every other part of the application.

However, you shouldn't make the _selector_ aware of the whole state shape. A _selector_ should be [co-located](https://stackoverflow.com/a/41860269) and only care about a particular slice of the state. Computing derived state from multiple sources in the Store should be done by composing _selectors_ instead.

The purpose of this small utility is to reduce the boilerplate required to achieve these good practices, by exposing selectors which are bound to a particular slice of state.

## Installation

```sh
npm install --save @pintob/bind-selectors
```

## API

### `bindSelectors(context, selectors)`

Returns a collection of functions where each function is bound to the provided slice of state. Instead of an object, one can provide a single function, which gets bound as well.

#### Arguments

- `context` (_String_|_Function_): Object path or a mapping function
- `selectors` (_Object_|_Function_): A collection of selectors or a single function

#### Example

```js
// when providing a single selector
const selector = user => user;
const fn = bindSelectors("path.to.user", selector);
fn(state); // sames as: state => state.path.to.user

// when providing a mapping function
const fn = bindSelectors(state => state.path.to.user, selector);
// the return value of the mapping function is
// provided as the argument of the selector
fn(state);
```

## The Gist

```js
// let's consider the following Store shape
const store = {
  entities: {
    user: {},
    events: []
  }
};

// and a couple of co-located selectors
const getOverdueEvents = events => events.filter(ev => ev.dueDate < Date.now());
const getEventsOfType = (events, type) => events.filter(ev => ev.type === type);

// we bind these selectors to their slice of state
const eventSelectors = bindSelectors("entities.events", {
  getOverdueEvents,
  getEventsOfType
});

// so we can then use them elsewhere, by providing the whole state
// but each selector isn't aware of the whole tree, only a subsection
const mapStateToProps = state => ({
  overdueEvents: eventSelectors.getOverdueEvents(state),
  musicEvents: eventSelectors.getEventsOfType(state, "music")
});
```