open-index/open-npm huggingface dataset:
npm package: @j.balek/vegasnap
Description: Vega Metamask Snap that adds Vega support for Metamask
Latest version: 0.1.3

# Vega Snap

This snap adds support for the Vega Protocol network to MetaMask.
It supports `client.list_keys`, `client.get_chain_id` and `client.send_transaction`
from the Vega Wallet API. `client.connect_wallet` and `client.disconnect_wallet`
are no-op's, but kept to provide compatibility with the Vega Wallet API.

## Testing

The snap comes with some basic tests, to demonstrate how to write tests for
snaps. To test the snap, run `yarn test` in this directory. This will use
[`@metamask/snaps-jest`](https://github.com/MetaMask/snaps/tree/main/packages/snaps-jest)
to run the tests in `src/index.test.ts`.

## Notes

- Babel is used for transpiling TypeScript to JavaScript, so when building with
  the CLI, `transpilationMode` must be set to `localOnly` (default) or
  `localAndDeps`.
npm package: @j.hughes.cu/pdf-converter
Description: Interactive PDF conversion dashboard with HTML editing, highlights, history, and export formats
Latest version: 1.6.0

# PDF Converter

Interactive PDF conversion dashboard that extracts PDF content and exports multiple formats (interactive HTML, highlighted HTML, canvas HTML, text, CSV, H5P, images).

For a semi-technical setup and operations guide (including Node installation and port-clear troubleshooting), see [USER_GUIDE.md](USER_GUIDE.md).
Word-format version: [PDF_Converter_User_Guide.rtf](PDF_Converter_User_Guide.rtf)

## Install

### Global CLI install (recommended)
```bash
npm install -g @j.hughes.cu/pdf-converter
pdf-converter
```

## Run

Start server:
```bash
pdf-converter
```

Show CLI help:
```bash
pdf-converter --help
```

Start on a custom port:
```bash
pdf-converter --port 3010
# or
pdf-converter 3010
```

If port `3000` is already in use:
```bash
portclear
pdf-converter
```

`portclear` asks for confirmation before stopping processes. To skip prompts:
```bash
portclear --yes
```

To explicitly clear all listeners on port 3000:
```bash
portclear --all
```

For a custom app port:
```bash
portclear 3010
```

If the blocked process is auto-restarted by a parent Node process, `portclear` will also stop that related parent supervisor.
Processes that look like this app are labeled as `[pdf-converter]` in `portclear` output.

Compatibility alias (still supported): `pdf-converter-portclear`

Open:
```text
http://localhost:3000
```

Put input PDFs in:
- `input/`

Generated files appear in:
- `output/<pdf-name>/`

## First Run (Empty `input/` + `output/`)

If both folders are empty, the app now shows an introduction page at startup.

Use this quick flow:
1. Add one or more PDF files to `input/`
2. Refresh `http://localhost:3000`
3. In the dashboard, choose output formats and click **Start Processing**
4. Open generated files from the output menu

The intro page is only shown when there are no input PDFs and no converted output folders yet.

## Publish to npm

1. Verify account/session:
```bash
npm whoami
```

2. Validate package contents:
```bash
npm run pack:check
```

3. Bump version:
```bash
npm version patch
```

4. Publish publicly:
```bash
npm publish --access public
```

## Notes

- Requires Node.js `>=18.18.0`
- If npm 2FA is enabled, publish will require OTP
- Package exposes CLI command: `pdf-converter`
- Package also exposes: `portclear` and `pdf-converter-portclear` (both clear listeners on port `3000`)
npm package: @j.u.p.iter/create-api-listener
Description: Listen api until it gives you, what you want
Author: Leontyev Kirill
Latest version: 1.0.2

[![Coverage Status](https://coveralls.io/repos/github/j-u-p-iter/api-listener/badge.svg?branch=master)](https://coveralls.io/github/j-u-p-iter/api-listener?branch=master)
[![Travis (.org) branch](https://img.shields.io/travis/rust-lang/rust/master.svg)](https://travis-ci.org/j-u-p-iter/api-listener)
[![npm](https://img.shields.io/npm/v/@j.u.p.iter/api-listener.svg)](https://www.npmjs.com/package/@j.u.p.iter/api-listener)

# api-listener
Listen api until it gives you, what you want)
npm package: @j.u.p.iter/env-manager
Description: The tool to manage environment variables with ease
Author: Leontyev Kirill
Latest version: 1.3.1

# env-manager
Managing env variables in javascript application with ease.

## Why one more tool for the managing of the environment variables?

As developers we have to manage environment variables in different environments.

And environment is not only determined by the value of NODE_ENV variable. It's determined, where you run your code:

- local machine.
- CI tool to run tests, to publish docker images.
- Deployment on some cloud.



We know, that we shouldn't commit .env file. So, there're a lot (huge) amount of ways to manage environment variables in different variables:

### On local machine 
We used to have .env file. 

### On CI 

We used to use SETTINGS to set up env variables 

### On clouds 

There's also special section to manage all this stuff or we also have to add .env file there manually.

So, in different environments we manage environment variables separately. And it adds big layer of complexity and source of issues.

We created this tool to simplify process of managing of environment variables to make it joyable and pretty fast.

## How to use

In the root of your project you should create env.js file. 

This file should create object with variables for absolutely all environments:

```typescript
const config = {
  development: {...},
  test: {...},
  ci: {...},
  production: {...},
}
```

You should include env.js into .gitignore file, cause you should hide your credentials.

Before adding and commiting changes you should run

```bash
@j.u.p.iter/env-manager encrypt
```

You'll be able to find newly created file into the root directory: env.enc.js (enc part stands for `encrypted`). This file should be added and commited.

In the entry point file of your project you should write:

```typescript
import { envManager } from '@j.u.p.iter/env-manager';

envManager()
```

What it does:

- decrypts file env.enc.js
- read config according to running environment
- add config to process.env

You should point out NODE_ENV in script, that you use to run your project. This way manager understands, what config it should extract from env.enc.js and merge into process.env.
npm package: @j.u.p.iter/google-oauth-client
Description: Google OAuth Client
Author: Leontyev Kirill
Latest version: 1.1.0

We use Google People API to retrieve user data:
- https://developers.google.com/people/api/rest/v1/people/get

About people.get method:
- https://developers.google.com/people/api/rest/v1/people/get

About scopes:
- https://developers.google.com/people/v1/how-tos/authorizing
npm package: @j.u.p.iter/moxios
Description: Mock axios requests for testing
Author: Matt Zabriskie
Latest version: 0.1.0

# moxios [![build status](https://img.shields.io/travis/mzabriskie/moxios.svg?style=flat-square)](https://travis-ci.org/mzabriskie/moxios)

Mock [axios](https://github.com/mzabriskie/axios) requests for testing

## Installing

```bash
$ npm install moxios --save-dev
```

## Example

```js
import axios from 'axios'
import moxios from 'moxios'
import sinon from 'sinon'
import { equal } from 'assert'

describe('mocking axios requests', function () {

  describe('across entire suite', function () {

    beforeEach(function () {
      // import and pass your custom axios instance to this method
      moxios.install()
    })

    afterEach(function () {
      // import and pass your custom axios instance to this method
      moxios.uninstall()
    })

    it('specify response for a specific request', function (done) {
      let input = document.querySelector('.UserList__Filter__Input')
      let button = document.querySelector('.UserList__Filter__Button')

      input.value = 'flintstone'
      button.click()

      // Elsewhere in your code axios.get('/users/search', { params: { q: 'flintstone' } }) is called

      moxios.wait(function () {
        let request = moxios.requests.mostRecent()
        request.respondWith({
          status: 200,
          response: [
            { id: 1, firstName: 'Fred', lastName: 'Flintstone' },
            { id: 2, firstName: 'Wilma', lastName: 'Flintstone' }
          ]
        }).then(function () {
          let list = document.querySelector('.UserList__Data')
          equal(list.rows.length, 2)
          equal(list.rows[0].cells[0].innerHTML, 'Fred')
          equal(list.rows[1].cells[0].innerHTML, 'Wilma')
          done()
        })
      })
    })

    it('stub response for any matching request URL', function (done) {
      // Match against an exact URL value
      moxios.stubRequest('/say/hello', {
        status: 200,
        responseText: 'hello'
      })

      // Alternatively URL can be a RegExp
      moxios.stubRequest(/say.*/, {/* ... */})

      let onFulfilled = sinon.spy()
      axios.get('/say/hello').then(onFulfilled)

      moxios.wait(function () {
        equal(onFulfilled.getCall(0).args[0].data, 'hello')
        done()
      })
    })

  })

  it('just for a single spec', function (done) {
    moxios.withMock(function () {
      let onFulfilled = sinon.spy()
      axios.get('/users/12345').then(onFulfilled)

      moxios.wait(function () {
        let request = moxios.requests.mostRecent()
        request.respondWith({
          status: 200,
          response: {
            id: 12345, firstName: 'Fred', lastName: 'Flintstone'
          }
        }).then(function () {
          equal(onFulfilled.called, true)
          done()
        })
      })
    })
  })

})
```

## Thanks

moxios is heavily inspired by [jasmine-ajax](https://github.com/jasmine/jasmine-ajax)

## License

MIT
npm package: @j.u.p.iter/react-router-with-scroll
Description: Allows to set up conditional scrolling with react router with ease.
Author: Leontyev Kirill
Latest version: 1.4.0

<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->

- [react-router-with-scroll](#react-router-with-scroll)

<!-- END doctoc generated TOC please keep comment here to allow auto update -->

# react-router-with-scroll

Scroll by condition in React Router with ease

Docs now in beta testing ;)
npm package: @j.u.p.iter/ts-compiler
Description: 1. Set up options on class create 2. Set up https://github.com/evanw/node-source-map-support on class create 3. Compile on compile method call. 4. Compile with TS api: this.ts.transpileModule 5. Cache with in-files-cache + in memory.
Author: Leontyev Kirill
Latest version: 1.1.0

# ts-compiler

1. Set up options on class create
2. Set up https://github.com/evanw/node-source-map-support on class create
3. Compile on compile method call.
4. Compile with TS api: this.ts.transpileModule
5. Cache with in-files-cache + in memory.

## Force some compiler options on class initialization step:

Source maps map compiled file to the original file, line by line, character by character. For example, it says, that charachter 5 on line 2 in the compiled file is represented by a charachter 10 on line 10 in the original file. Such types of maps allow, for example, debuger to show the original file, using this map. In another words dubugger, using source maps, creates representation of the original file. Another use case of source map usage 

/**
 * 

 * There are two possible ways of configuring ts with sourcemaps:
 *   - sourceMap - this is the way to tell TS to emit source maps in the separate files 
 *     alongside their corresponding ts files. In this case  To let a debugger or any another client, that uses source map, knowledge about this source map,
       the link to the generated source maps will be placed into the compiled files. Example of such a link can look like this: `//# sourceMappingURL=main.js.map`.
 *
 *   - inlineSourceMap - in this way instead of having a separate file with source maps, the contents of that file will be included into the compiled file.
 *
 */
`inlineSourceMap` to true;