open-index/open-npm huggingface dataset:
npm package: @mesofi/uikit
Description: Set of UI components for meso projects
Latest version: 0.56.1

# 🥞 Pancake UIkit

[![Version](https://img.shields.io/npm/v/@pancakeswap-libs/uikit)](https://www.npmjs.com/package/@pancakeswap-libs/uikit) [![Size](https://img.shields.io/bundlephobia/min/@pancakeswap-libs/uikit)](https://www.npmjs.com/package/@pancakeswap-libs/uikit)

Pancake UIkit is a set of React components and hooks used to build pages on Pancake's apps. It also contains a theme file for dark and light mode.

## Install

`yarn add @pancakeswap-libs/uikit`

## Setup

### Theme

Before using Pancake UIkit, you need to provide the theme file to styled-component.

```
import { ThemeProvider } from 'styled-components'
import { light, dark } from '@pancakeswap-libs/uikit'
...
<ThemeProvider theme={isDark}>...</ThemeProvider>
```

### Reset

A reset CSS is available as a global styled component.

```
import { ResetCSS } from '@pancakeswap-libs/uikit'
...
<ResetCSS />
```

### Types

This project is built with Typescript and export all the relevant types.

## How to use the UIkit

If you want to use components from the UIkit, check the [Storybook documentation](https://pancakeswap.github.io/pancake-uikit/)
npm package: @mesoneer-ag/mideal-embed
Description: A small module for embedding m_IDeal into another web page
Latest version: 1.1.0

# Mideal Embed

## Overview
This package provides a way for embedding m_IDeal into another web page.

## Installation
To install this package, run the following command:
```bash
npm install @mesoneer-ag/mideal-embed
```
## Usage
For detailed documentation, please visit our GitBook page: Project Documentation

## License
This project is licensed under the MIT License - see the LICENSE file for details.
npm package: @mesos-playground/seneca-proxies
Description: Seneca proxies for testing mesos service discovery.
Author: Ian Laird
Latest version: 1.2.0

# seneca-proxies

Seneca proxies for testing mesos service discovery.

## MathProxy

Example

```node

const proxies = require('@mesos-playground/seneca-proxies');

var math = new proxies.MathProxy({
    host: 'mathService.marathon.l4lb.dcos.directory',
    port: 18650
});

math.sum(1, 2).then(sum=>{
    console.log("Sum:", sum);
});
```

## UuidProxy

Example

```node

const proxies = require('@mesos-playground/seneca-proxies');

var uuid = new proxies.UuidProxy({
    host: 'uuidService.marathon.l4lb.dcos.directory',
    port: 18650
});

uuid.generate().then(id=>{
    console.log("uuid:", id);
});
```
npm package: @mesosphere/mockserver
Description: A mockserver that allows you to mock XHR, long-polling XHR, server sent events and websocket connections
Author: DanielMSchmidt
Latest version: 4.0.0

# Mockserver

## Usage

We provide two interfaces, a CLI for the fast and easy way to interact with the mock server and a programmatic API to give you the control over everything.

### CLI

The CLI is entirely controlled via environment variables, here are the ones you may configure

* `PROXY_HOST_PORT` (required): determine where to send the requests no mock matches against to. E.g. "my-service.com:2342"
* `MOCK_SEARCH_EXPRESSION` (required): glob to specify where to search for mocks. E.g. "./\*_/_-mock.js"
* `PORT` (optional): port of the mockserver

Your mocks should be defined in Javascript files as named export:

```js
// The name is important!
export const mocks = [
  {
    id: "my-first-mock",
    request: (req, res) => {
      // Same interface as express middlewares
      res.status(200);
    }
  }
];
```

Please note that we import these files at start time of the mockserver.

### API

```ts
import mockserver from "mockserver";
// Every option is required
const { port, close } = await mockserver({
  port: 0, // zero means "choose your own"
  proxyHost: "my-service",
  proxyPort: 42,
  mocks: [
    {
      id: "my-first-mock",
      request: (req, res) => {
        // Same interface as express middlewares
        res.status(200);
      }
    }
  ]
});
```

## Development

* Installation: `npm install`
* Start production server: `npm start`
* Start development server: `npm run watch`

## Testing

Please run `npm test`
npm package: @mess/prettier-config
Description: Mess's Prettier config
Author: Jonathan Knoll
Latest version: 0.0.3

# `@mess/prettier-config`

> Mess's [Prettier](https://prettier.io) config.

## Usage

**Install**:

```bash
$ yarn add --dev @mess/prettier-config
```

**Edit `package.json`**:

```jsonc
{
  // ...
  "prettier": "@mess/prettier-config"
}
```
npm package: @message-queue-toolkit/amqp
Description: AMQP adapter for message-queue-toolkit
Latest version: 24.0.0

# AMQP (Advanced Message Queuing Protocol)

The library provides support for both direct exchanges and topic exchanges.

> **_NOTE:_** Check [README.md](../../README.md) for transport-agnostic library documentation.

## Publishers

Use `AbstractAmqpQueuePublisher` to implement direct exchange and `AbstractAmqpTopicPublisher` for topic exchange.

See [test publisher](test/publishers/AmqpPermissionPublisher.ts) for an example of implementation.

## Consumers

Use `AbstractAmqpQueueConsumer` to implement direct exchange and `AbstractAmqpTopicConsumer` for topic exchange.

See [test consumer](test/consumers/AmqpPermissionConsumer.ts) for an example of implementation.

## Automatic Reconnects

`message-queue-toolkit` automatically reestablishes connections for all publishers and consumers via `AmqpConnectionManager` mechanism.

Example:

```ts
export const TEST_AMQP_CONFIG: AmqpConfig = {
  vhost: '',
  hostname: 'localhost',
  username: 'guest',
  password: 'guest',
  port: 5672,
  useTls: false,
}

const amqpConnectionManager = new AmqpConnectionManager(config, logger)
await amqpConnectionManager.init()

const publisher = new TestAmqpPublisher(
  { amqpConnectionManager },
  {
    // other amqp options
  },
)
await publisher.init()

const consumer = new TestAmqpConsumer(
  { amqpConnectionManager },
  {
    // other amqp options
  },
)
await consumer.start()

// break connection, to simulate unexpected disconnection in production
await (await amqpConnectionManager.getConnection()).close()

const message = {
  // some test message
}

// This will fail, but will trigger reconnection within amqpConnectionManager
publisher.publish(message)

// eventually connection is reestablished and propagated across all the AMQP services that use same amqpConnectionManager

// This will succeed and consumer, which also received new connection, will be able to consume it
publisher.publish(message)
```

## Lazy instantiation

By default `message-queue-toolkit/amqp` will lazily instantiate publishers before the publish in case they weren't instantiated before. This may result in system not failing fast when connection to AMQP cannot be established, as instantiation happens asynchronously. In case that is an undesirable behaviour, you can set parameter `isLazyInitEnabled` to false either directly for a publisher, or as one of the `newPublisherOptions` parameters for the `AmqpQueuePublisherManager`.

In case when lazy instantiation is disabled, publishers should be initialized explicitly by using an async `AmqpQueuePublisherManager.initRegisteredPublishers()` method. It also has an optional `publishers?: string[]` argument, which can be used to only initialize some specific publishers.
npm package: @message-queue-toolkit/kafka
Description: Kafka adapter for message-queue-toolkit
Latest version: 0.11.0

# Kafka
    
This library provides utilities for implementing Kafka consumers and publishers.
While following the same patterns as other message broker implementations,
Kafka's unique characteristics require some specific adaptations in the publisher and consumer definitions.

> **_NOTE:_** Check [README.md](../../README.md) for transport-agnostic library documentation.

## Publishers

Use `AbstractKafkaPublisher` as a base class for publisher implementation.

See [test publisher](test/publisher/PermissionPublisher.ts) for an example of implementation.

## Consumers

Use `AbstractKafkaConsumer` as a base class for consumer implementation.

See [test consumer](test/consumer/PermissionConsumer.ts) for an example of implementation.

## Batch Processing

Kafka supports batch processing for improved throughput. To enable it, set `batchProcessingEnabled` to `true` and 
configure `batchProcessingOptions`.

When batch processing is enabled, message handlers receive an array of messages instead of a single message.

### Configuration Options

- `batchSize` - Maximum number of messages per batch
- `timeoutMilliseconds` - Maximum time to wait for a batch to fill before processing

### How It Works

Messages are buffered per topic-partition combination. Batches are processed when either:
- The buffer reaches the configured `batchSize`
- The `timeoutMilliseconds` timeout is reached since the first message was added

After successful batch processing, the offset of the last message in the batch is committed.

See [test batch consumer](test/consumer/PermissionBatchConsumer.ts) for an example of implementation.
npm package: @messageformat/core
Description: PluralFormat and SelectFormat Message and i18n Tool - A JavaScript Implemenation of the ICU standards.
Latest version: 3.4.0

<div class="main-title">
<img align="right" width="100" height="100" src="https://messageformat.github.io/messageformat/logo/messageformat.svg">
<h1>messageformat</h1>
</div>

The experience and subtlety of your program's text is important.
The messageformat project provides a complete set of tools for handling all the messages of your application, for both front-end and back-end environments; for both runtime and build-time use.
It's built around the ICU MessageFormat standard and supports [all the languages](http://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html) included in the [Unicode CLDR](http://cldr.unicode.org/), but it can be just as useful if you're dealing with only one of them.

[ICU MessageFormat](https://unicode-org.github.io/icu/userguide/format_parse/messages/) is a mechanism for handling both **pluralization** and **gender** in your applications.
This is the core compiler of a [JavaScript project](http://messageformat.github.io/) supports and extends all parts of the official Java/C++ implementation, with the exception of the deprecated ChoiceFormat.
In addition to compiling messages into JavaScript functions, it also provides tooling for making their use easy during both the build and runtime of your site or application.

For more details, please see the project's documentation site: http://messageformat.github.io/

This package was previously named [messageformat](https://www.npmjs.com/package/messageformat).

---

Messageformat is an OpenJS Foundation project, and we follow its [Code of Conduct](https://code-of-conduct.openjsf.org/).

Copyright [OpenJS Foundation](https://openjsf.org) and messageformat contributors. All rights reserved.
The [OpenJS Foundation](https://openjsf.org) has registered trademarks and uses trademarks.
For a list of trademarks of the [OpenJS Foundation](https://openjsf.org), please see our [Trademark Policy](https://trademark-policy.openjsf.org/) and [Trademark List](https://trademark-list.openjsf.org/).
Trademarks and logos not indicated on the [list of OpenJS Foundation trademarks](https://trademark-list.openjsf.org) are trademarks™ or registered® trademarks of their respective holders. Use of them does not imply any affiliation with or endorsement by them.

Browser testing provided by:

<a href="https://www.browserstack.com/open-source">
<img width=200 alt="BrowserStack" src="https://messageformat.github.io/messageformat/logo/browserstack.svg" />
</a>