open-index/open-npm huggingface dataset:
npm package: @lufycz/sushi-vesting-query
Description: This is a script that fetches the pending and harvested Sushi at the specified blocks, and then calculates the resulting vested Sushi.
Author: LufyCZ
Latest version: 1.0.0

# sushi-vesting-query

This is a script that fetches the pending and harvested Sushi at the specified blocks, and then calculates the resulting vested Sushi.

Run
```
yarn

yarn run standalone -s <startBlock> -e <endBlock> -c <claimBlock>
```

Resulting files will be under the /outputs folder

## Options
`-s` - Start Block, defaults to 10959148 (vesting start), defines the start of the period of the calculation

`-e` - End Block, required, defines the end of the period of the calculation

`-c` - Claim Block, default to current block height, defines the block of the snapshot of claimed amounts

## Blacklist was generated like this:
```
yarn run standalone -e 12148193

yarn run generate-blacklist -l 6666666666666666666666 -i outputs/amounts-10959148-12148193.json
```

To replicate, make sure to start with a clean blacklist (`[]`), otherwise you'll get an empty output from `generate-blacklist`.
npm package: @lug/e-pigeon
Description: Handmade messaging protocol implemented in js
Author: Westixy
Latest version: 1.0.2

# ![logo](https://raw.githubusercontent.com/Lughus/e-pigeon/master/ressources/logo.png) e-pigeon

Implementation of an handmade application protocol for messaging

Be careful this is an alpha version of the software and many bugs can be found in it. If you use it and found some, please create an issue, it can be helpful.

## What does it do ?

That's a simple messaging server / client using node-ipc in the hood\
It garantee the order of sended messages and that the message has been received.\
You can send a message to a group of clients.\
Server cannot receive message, but you can start a client in the same app of the server and will use localhost to communicate.

## Getting started

Works on node 8+\
Install it with `npm i @lug/e-pigeon`

You can check [example](https://github.com/Lughus/e-pigeon/tree/master/example) for an simple use of this module.

### Server

```js
const { EPigeonServer } = require('@lug/e-pigeon')
const server = new EPigeonServer()
server.serve(9999)
```

### Client

```js
const { EPigeonClient } = require('@lug/e-pigeon')
const client = new EPigeonClient()
client.connect('host', 9999)
```

## Documentation

For debugging, you can set the env debug variable to `epigeon:*` like described in the [debug](https://github.com/visionmedia/debug) module

### Server

#### Methods

| name  | params   | description        |
| ----- | -------- | ------------------ |
| serve | port:Int | serve on this port |
| stop  | -        | stop the server    |

### Client

#### Methods

| name| params| description|
|-|-|-|
| connect| host:string / port:Int| connect to server|
| disconnect|-| disconnect from server|
| updateSession | {key:value,...}| set values to your client session|
| sendMessage   | to: uuid or {key:value} / content:any | send a message to a uuid or to all client that match the key:value on their session |


#### Events

You can add en event handler with `client.on(<event>, <callback>)`

| event | callback params | description|
|-|-|-|
| connected| - | when the client is connected to the server|
| disconnected | - | when the client is disconnected|
| authenticated | - | when the client is authenticated|
| session.update | {uuid, session} | when a client update his session|
| message | message | when a message is recieved, contains many things but the content is stored in `message.payload`
| client.connect | uuid | when a client connect to the server|
| client.disconnect | uuid | when a client disconnect from the server|
npm package: @lug/netproxy
Description: NetProxy used to abstract what system you use to communicate on network
Author: Westixy
Latest version: 1.0.1

# NetProxy

NetProxy is a simple "interface" that is will be used to wrap a net utils so we can swap between them easily.

## Create a new proxy

- install `npm i @lug/netproxy`
- import 
```js
const {NetClientProxy, NetServerProxy} = require('@lug/netproxy')
class Server extends NetServerProxy { ... }
class Client extends NetClientProxy { ... }
```

please see `https://github.com/Lughus/NetProxy-events` for an example for how it works

## Methods

At the end you will have this

- Server
  - listen(port)
  - stop()
  - send(socket,data)
- Client
  - connect(ip,port)
  - disconnect()
  - send(data)

and some events that are triggered when it needs to

## Events

An event is fired with `this.ev.emit('event'[,arg])`

### Server

| event             | arg          | type        | description                     |
| ----------------- | ------------ | ----------- | ------------------------------- |
| error             | error        | any         | when an error happen            |
| start             | -            | -           | when the server start listening |
| stop              | -            | -           | when the server stop            |
| socket.connect    | socket       | socket      | when a client connect           |
| socket.disconnect | socket       | socket      | when a client disconnect        |
| socket.data       | socket, data | socket, any | when a client send data         |

### Client

| event             | arg    | type        | description                       |
| ----------------- | ------ | ----------- | --------------------------------- |
| error             | error  | any         | when an error happen              |
| connect           | -      | -           | when the client is connecting     |
| connected         | socket | socket      | when the client is connected stop |
| disconnect        | -      | -           | when a client disconnect          |
| destroy           | -      | -           | when a client is destroyed        |
| data              | data   | any         | when a client recieve data        |
npm package: @lug/netproxy-events
Description: NetProxy example of use with events from node
Author: Westixy
Latest version: 1.0.1

# NetProxy - Events

Example of use with events from node

## Getting started

- install `npm i @lug/netproxy-events`
- use it 
```js
const {NetClientProxyEmitter, NetServerProxyEmitter} = require('@lug/netproxy')

const client = new NetClientProxyEmitter()
const server = new NetServerProxyEmitter()

server.listen(9999)

server.ev.on('socket.data',(socket, data)=>{
  server.send(socket, `I received your message : """${data}"""`)
})

client.connect('localhost',9999)

client.send('Hey srv its me')

client.disconnect()

server.stop()
```

## Methods

At the end you will have this

- Server
  - listen(port)
  - stop()
  - send(socket,data)
- Client
  - connect(ip,port)
  - disconnect()
  - send(data)

and some events that are triggered when it needs to

## Events

An event is fired with `this.ev.emit('event'[,arg])`

### Server

| event             | arg          | type        | description                     |
| ----------------- | ------------ | ----------- | ------------------------------- |
| error             | error        | any         | when an error happen            |
| start             | -            | -           | when the server start listening |
| stop              | -            | -           | when the server stop            |
| socket.connect    | socket       | socket      | when a client connect           |
| socket.disconnect | socket       | socket      | when a client disconnect        |
| socket.data       | socket, data | socket, any | when a client send data         |

### Client

| event             | arg    | type        | description                       |
| ----------------- | ------ | ----------- | --------------------------------- |
| error             | error  | any         | when an error happen              |
| connect           | -      | -           | when the client is connecting     |
| connected         | socket | socket      | when the client is connected stop |
| disconnect        | -      | -           | when a client disconnect          |
| destroy           | -      | -           | when a client is destroyed        |
| data              | data   | any         | when a client recieve data        |
npm package: @lug/netproxy-node-ipc
Description: NetProxy implementation of node-ipc
Author: Westixy
Latest version: 1.0.2

# NetProxy - node-ipc

Implementation of node-ipc in this module

## Getting started

- install `npm i @lug/netproxy-node-ipc`
- use it 
```js
const {
  NetClientProxyNodeIpc,
  NetServerProxyNodeIpc
} = require('../netProxy')

const client = new NetClientProxyNodeIpc()
const server = new NetServerProxyNodeIpc()


server.ev.on('socket.data', (socket, data) => {
  server.send(socket, `I received your message : """${data}"""`)
})
server.ev.on('start', ()=>{
  setTimeout(client.disconnect.bind(client),1000)
  setTimeout(server.stop.bind(server),2500)
})

client.ev.on('connected', ()=>{
  client.send('Hey srv its me')
})

client.connect('localhost', 9999)
server.listen(9999)
```

## Methods

At the end you will have this

- Server
  - listen(port)
  - stop()
  - send(socket,data)
- Client
  - connect(ip,port)
  - disconnect()
  - send(data)

and some events that are triggered when it needs to

## Events

An event is fired with `this.ev.emit('event'[,arg])`

### Server

| event             | arg          | type        | description                     |
| ----------------- | ------------ | ----------- | ------------------------------- |
| error             | error        | any         | when an error happen            |
| start             | -            | -           | when the server start listening |
| stop              | -            | -           | when the server stop            |
| socket.connect    | socket       | socket      | when a client connect           |
| socket.disconnect | socket       | socket      | when a client disconnect        |
| socket.data       | socket, data | socket, any | when a client send data         |

### Client

| event             | arg    | type        | description                       |
| ----------------- | ------ | ----------- | --------------------------------- |
| error             | error  | any         | when an error happen              |
| connect           | -      | -           | when the client is connecting     |
| connected         | socket | socket      | when the client is connected stop |
| disconnect        | -      | -           | when a client disconnect          |
| destroy           | -      | -           | when a client is destroyed        |
| data              | data   | any         | when a client recieve data        |
npm package: @lugamafe/nx-biome
Description: This library was generated with [Nx](https://nx.dev).
Author: LUGAMAFE
Latest version: 0.0.2-2

# nx-biome

This library was generated with [Nx](https://nx.dev).

## Building

Run `nx build nx-biome` to build the library.

## Running unit tests

Run `nx test nx-biome` to execute the unit tests via [Jest](https://jestjs.io).

## Usage

### Format Command

You can use the format executor with the following options:

```bash
# Basic usage
nx format yourProjectName

# With write flag to apply changes
nx format yourProjectName --write

# With unsafe flag to allow unsafe operations
nx format yourProjectName --unsafe

# Combine both flags
nx format yourProjectName --write --unsafe
```

### Lint Command

Similarly for the lint command:

```bash
# Basic usage
nx lint yourProjectName

# With write flag to apply fixes
nx lint yourProjectName --write

# With unsafe flag
nx lint yourProjectName --write --unsafe
```

### Check Command

For check command:

```bash
# Basic usage
nx check yourProjectName

# With write and unsafe flags
nx check yourProjectName --write --unsafe
```

### Overriding Default Flags

If an executor has `--write` or `--unsafe` flags configured as `true` by default in your project configuration, you can override them using the `--no-write` or `--no-verify` flags:

```bash
# Override default write=true configuration
nx format yourProjectName --no-write

# Override default unsafe=true configuration
nx lint yourProjectName --no-verify

# Override both default configurations
nx check yourProjectName --no-write --no-verify
```

### Default Executor Configuration Example

Here's an example of how an executor might be configured with default flags in your `project.json` file:

```json
{
  "projects": {
    "your-project": {
      "targets": {
        "format": {
          "executor": "@lugamafe/nx-biome:format",
          "options": {
            "write": true,
            "unsafe": true
          }
        },
        "lint": {
          "executor": "@lugamafe/nx-biome:lint",
          "options": {
            "write": true
          }
        }
      }
    }
  }
}
```

With this configuration, the `format` command would run with both `--write` and `--unsafe` enabled by default, and you would need to use `--no-write` or `--no-verify` to disable them.
npm package: @lugardetech/gestao-empresarial
Description: Módulo de Gestão Empresarial do Sistema de Licitações
Author: Licita IA
Latest version: 1.0.4

# @licita/gestao-empresarial

Módulo de Gestão Empresarial do Sistema de Licitações.

## Funcionalidades

- ✅ CRUD completo de empresas
- ✅ Validação de CNPJ
- ✅ Hooks React para gerenciamento de estado
- ✅ Integração com Supabase
- ✅ Tipos TypeScript completos

## Instalação

```bash
npm install @licita/gestao-empresarial @licita/shared-libs
```

## Uso

### Services

```typescript
import { EmpresaService } from '@licita/gestao-empresarial'

// Listar empresas
const empresas = await EmpresaService.listar()

// Criar empresa
const novaEmpresa = await EmpresaService.criar({
  cnpj: '12345678000190',
  razao_social: 'Empresa Exemplo LTDA',
  tipo_empresa: 'LTDA'
})

// Validar CNPJ
const isValid = EmpresaService.validarCnpj('12345678000190')

// Formatar CNPJ
const formatted = EmpresaService.formatarCnpj('12345678000190')
```

### Hooks React

```typescript
import { useEmpresas, useEmpresa } from '@licita/gestao-empresarial'

function EmpresasPage() {
  const { empresas, loading, error, criar, atualizar, desativar } = useEmpresas()

  const handleCreate = async (data) => {
    try {
      await criar(data)
      // Empresa criada com sucesso
    } catch (error) {
      // Tratar erro
    }
  }

  if (loading) return <div>Carregando...</div>
  if (error) return <div>Erro: {error}</div>

  return (
    <div>
      {empresas.map(empresa => (
        <div key={empresa.id}>{empresa.razao_social}</div>
      ))}
    </div>
  )
}

function EmpresaDetails({ id }: { id: string }) {
  const { empresa, loading, error } = useEmpresa(id)

  if (loading) return <div>Carregando...</div>
  if (error) return <div>Erro: {error}</div>
  if (!empresa) return <div>Empresa não encontrada</div>

  return <div>{empresa.razao_social}</div>
}
```

### Tipos

```typescript
import { EmpresaFormData, TIPOS_EMPRESA } from '@licita/gestao-empresarial'

const formData: EmpresaFormData = {
  cnpj: '12345678000190',
  razao_social: 'Empresa Exemplo',
  tipo_empresa: 'LTDA'
}

// Lista de tipos de empresa
TIPOS_EMPRESA.forEach(tipo => {
  console.log(tipo.value, tipo.label)
})
```

## Dependências

- `@licita/shared-libs`: Bibliotecas compartilhadas
- `@supabase/supabase-js`: Cliente Supabase
- `react`: React (peer dependency)
- `react-hook-form`: Formulários (peer dependency)
- `zod`: Validação (peer dependency)

## Desenvolvimento

```bash
# Instalar dependências
npm install

# Build
npm run build

# Watch mode
npm run dev

# Testes
npm test

# Lint
npm run lint
```

## Estrutura

```
src/
├── services/           # Lógica de negócios
│   └── EmpresaService.ts
├── hooks/              # React hooks
│   └── useEmpresas.ts
├── types/              # Tipos TypeScript
│   └── empresa.ts
└── index.ts           # Exports públicos
```
npm package: @lugardetech/shared-libs
Description: Bibliotecas compartilhadas do Sistema de Licitações
Author: Licita IA
Latest version: 1.1.5

# @licita/shared-libs

Bibliotecas compartilhadas do Sistema de Gestão de Licitações.

## Instalação

```bash
npm install @licita/shared-libs
```

## Uso

### Supabase

```typescript
import { createBrowserSupabaseClient, createServerSupabaseClient } from '@licita/shared-libs'

// Cliente browser
const supabase = createBrowserSupabaseClient()

// Cliente servidor (Next.js)
const supabase = await createServerSupabaseClient()
```

### UI Components

```typescript
import { Layout, PageHeader } from '@licita/shared-libs'

function MyPage() {
  return (
    <Layout title="Minha Página">
      <PageHeader 
        title="Dashboard" 
        subtitle="Visão geral do sistema"
        actions={<button>Nova Ação</button>}
      />
      {/* conteúdo */}
    </Layout>
  )
}
```

### Utilitários

```typescript
import { validateCnpj, formatCnpj, formatCurrency } from '@licita/shared-libs'

const isValid = validateCnpj('12345678000190')
const formatted = formatCnpj('12345678000190') // 12.345.678/0001-90
const price = formatCurrency(1234.56) // R$ 1.234,56
```

### Tipos

```typescript
import { ApiResponse, User, LoadingState } from '@licita/shared-libs'

const response: ApiResponse<User> = {
  data: { id: '1', email: 'user@example.com', ... },
  success: true
}
```

## Desenvolvimento

```bash
# Instalar dependências
npm install

# Build
npm run build

# Watch mode
npm run dev

# Testes
npm test

# Lint
npm run lint
```

## Publicação

Este pacote é publicado automaticamente no npm quando uma tag é criada no repositório.

```bash
npm version patch|minor|major
git push origin main --tags
```
npm package: @luggage/core
Description: Dropbox file API wrapper for storing json data.
Author: dra1n
Latest version: 2.2.2

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

Dropbox file API wrapper for storing json data.

> Have you ever noticed that their stuff is shit and your shit is stuff?
(George Carlin)

### Usage

```js
const backend = new DropboxBackend(token);
const store = new Luggage(backend);
const articles = store.collection('articles');
```

### Filtering

```js
articles.where({ author: 'John Doe' }).read().then((articles) => {
  console.log('John\'s articles:', articles);
});

/* or you can provide a function */
articles.where(article => article.authors.includes('John Doe')).read().then((articles) => {
  console.log('John\'s articles:', articles);
});

/* Listen to filtered data updates */
articles.where({ author: 'John Doe' }).on('data', (articles) => {
  console.log('John\'s articles:', articles);
});

/* You can stack conditions */
articles.where({ author: 'John Doe' }).where(article => article.comments > 0)

/* or more readable */
articles.where({ author: 'John Doe' }).and(article => article.comments > 0)

```

### Finding single record

```js
/* Collection#find returns the first record found */
articles.find({ author: 'John Doe' }).read().then((article) => {
  console.log('John\'s article:', article);
});

/* Collection#find takes a function */
articles.find(article => article.author === 'John Doe').read().then((article) => {
  console.log('John\'s article:', article);
});

/* Listen to single record updates */
articles.find({ author: 'John Doe' }).on('data', (article) => {
  console.log('John\'s article:', article);
});
```

### Updating record

```js
/* Simple merge with existing record */
articles.find({ id: 1 }).update({ author: 'Jane Doe' }).then(([article]) => {
  console.log('Author changed:', article.author);
});

/* Record#update takes a function (surprise :)) */
articles.find(article => article.id === 42).update((article) => {
  article.authors.push('Jane Doe');
  return article;           // Do not forget to return new record
})
```

### Adding new record

```js
articles.add({ author: 'John Doe', body: 'Blah blah blah mr. Freeman' }).then(([article]) => {
  console.log('New article was added:', article);
});
```

### Deleting record

```js
articles.find({ id: 1 }).delete().then(([article]) => {
  console.log('No longer within collection:', article);
});
```
npm package: @luggage/luggage-session
Description: Utils for obtaining and keeping dropbox authentication stuff in user session
Author: dra1n
Latest version: 2.2.0

# Luggage session manager

Utils for fetching and storing dropbox authentication token.

### Usage

```js
import LuggageSession from 'luggage-session'

const session = new LuggageSession({ apiKey: 'dropboxApiKey', redirectUrl: '/app'})

// If token already exists in memory or sessionStorage you will get it
// otherwise this will cause a redirect to dropbox authentication page
const token = session.getToken()
```