open-index/open-npm huggingface dataset:
npm package: @soulyard/shared-state-manager
Description: Librairie pour gérer un état partagé entre microfrontends avec RxJS.
Author: Allan
Latest version: 1.0.1

Voici un exemple de `README.md` clair et structuré pour ta bibliothèque `shared-state-manager`, adaptée pour une utilisation avec des microfrontends en Angular ou tout autre framework moderne supportant ESM.

---

## 📦 `shared-state-manager`

Librairie TypeScript + RxJS pour gérer un **état d'application partagé** entre plusieurs **microfrontends**.

### ✅ Fonctionnalités

- 📤 Chaque microfrontend peut **écrire uniquement dans son propre espace de noms**.
- 👀 Tous les microfrontends peuvent **lire l’état global** ou s’abonner uniquement à leur propre état.
- ⚡️ Réactif grâce à **RxJS**.
- 📦 Compatible **CommonJS** (Node) et **ESM** (Angular, Vite…).

---

## 🚀 Installation

```bash
npm install shared-state-manager
```

Assurez-vous que `rxjs` est aussi installé dans le projet hôte :

```bash
npm install rxjs
```

---

## 📚 Utilisation

### 1. 🔁 Mettre à jour l’état de son propre microfrontend

```ts
import sharedStateManager from 'shared-state-manager';

sharedStateManager.setMfeState('dataChooser', {
  selectedIds: [1, 2, 3]
});
```

---

### 2. 👀 Lire un état (snapshot)

```ts
const current = sharedStateManager.getMfeState('dataChooser');
```

---

### 3. 🔔 S’abonner aux changements de son propre espace

```ts
sharedStateManager.selectMfeState('dataChooser').subscribe(state => {
  console.log('Nouveau state pour dataChooser:', state);
});
```

---

### 4. 📡 S’abonner à l’état global

```ts
sharedStateManager.selectAll().subscribe(globalState => {
  console.log('État complet :', globalState);
});
```

---

## 🧱 Exemple d'intégration dans un microfrontend Angular

```ts
// app.component.ts
import { Component, OnInit } from '@angular/core';
import sharedStateManager from 'shared-state-manager';

@Component({
  selector: 'app-root',
  template: `<p>État : {{ data | json }}</p>`
})
export class AppComponent implements OnInit {
  data: any;

  ngOnInit(): void {
    sharedStateManager.selectMfeState('dataChooser').subscribe(state => {
      this.data = state;
    });

    sharedStateManager.setMfeState('dataChooser', { active: true });
  }
}
```

---

## 📦 Build local

```bash
npm run build
```

## 📤 Publication sur npm

```bash
npm login
npm publish --access public
```

---

Souhaites-tu également un exemple d’intégration dans un projet **monorepo Nx ou Turborepo** avec Angular et plusieurs microfrontends ?
npm package: @soulz-io/mcp
Description: Soulz — AI expert agents for Claude. One command, instant expertise.
Latest version: 1.0.3

# Soulz — AI Expert Agents for Claude

Soulz adds expert AI agents to your Claude. One command, and you can spawn specialists on demand — a LinkedIn copywriter, a financial analyst, a UX researcher, whatever you need.

## Install

Get your free license key at [soulz.io](https://soulz.io), then run:

```bash
claude mcp add --env SOULZ_LICENSE_KEY=your_key_here soulz -- npx @soulz-io/mcp
```

That's it. One command, done. Your key is included in the config so it persists between sessions.

## Use it

Just ask Claude what you need:

> *"I need a LinkedIn copywriter"*
>
> *"Spawn me a financial analyst"*
>
> *"What experts do you have for marketing?"*

Claude handles the rest. Your agent is ready in seconds.

## Pricing

| Plan | Agents | Price |
|------|--------|-------|
| **Free** | 1 agent | €0 |
| **Pro** | 5 agents | €9.99/mo |
| **Max** | Unlimited | €19.99/mo |

Sign up at [soulz.io](https://soulz.io) — your first agent is free.

## Available tools

Once installed, Claude gets three new tools:

- **soulz_spawn_expert** — Spawn an expert by role title
- **soulz_browse** — Browse available experts by category or search
- **soulz_quota** — Check your plan and remaining agents

## Requirements

- Node.js 18+
- Claude Code or Claude Cowork

## Links

- [soulz.io](https://soulz.io)
- [Browse experts](https://soulz.io/personalities)
npm package: @soumyajit4419/sdk-v2
Description: 🛠 An SDK for building applications on top of Uniswap.
Latest version: 3.0.5

# Uniswap SDK

[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
[![Actions Status](https://github.com/Uniswap/uniswap-sdk/workflows/CI/badge.svg)](https://github.com/Uniswap/uniswap-sdk)
[![npm version](https://img.shields.io/npm/v/@uniswap/sdk/latest.svg)](https://www.npmjs.com/package/@uniswap/sdk/v/latest)
[![npm bundle size (scoped version)](https://img.shields.io/bundlephobia/minzip/@uniswap/sdk/latest.svg)](https://bundlephobia.com/result?p=@uniswap/sdk@latest)

In-depth documentation on this SDK is available at [uniswap.org](https://uniswap.org/docs/v2/SDK/getting-started/).

## Running tests

To run the tests, follow these steps. You must have at least node v10 and [yarn](https://yarnpkg.com/) installed.

First clone the repository:

```sh
git clone https://github.com/Uniswap/uniswap-sdk.git
```

Move into the uniswap-sdk working directory

```sh
cd uniswap-sdk/
```

Install dependencies

```sh
yarn install
```

Run tests

```sh
yarn test
```

You should see output like the following:

```sh
yarn run v1.22.4
$ tsdx test
 PASS  test/constants.test.ts
 PASS  test/pair.test.ts
 PASS  test/fraction.test.ts
 PASS  test/miscellaneous.test.ts
 PASS  test/entities.test.ts
 PASS  test/trade.test.ts

Test Suites: 1 skipped, 6 passed, 6 of 7 total
Tests:       3 skipped, 82 passed, 85 total
Snapshots:   0 total
Time:        5.091s
Ran all test suites.
✨  Done in 6.61s.
```
npm package: @sound-advice/sound-advice-fe-utils
Description: To authenticate by logging in to npm, use the npm login command, replacing USERNAME with your GitHub username, TOKEN with your personal access token (classic), and PUBLIC-EMAIL-ADDRESS with your email address.
Latest version: 0.0.0

To authenticate by logging in to npm, use the npm login command, replacing USERNAME with your GitHub username, TOKEN with your personal access token (classic), and PUBLIC-EMAIL-ADDRESS with your email address.
npm package: @soundation/sharedb-mingo-memory
Description: In-memory database adapter with MongoDB API for ShareDB
Author: Avital Oliver
Latest version: 3.0.1

# ShareDBMingo

  [![NPM Version](https://img.shields.io/npm/v/@teamwork/sharedb-mingo-memory.svg)](https://npmjs.org/package/@teamwork/sharedb-mingo-memory)
  [![Build Status](https://travis-ci.org/Teamwork/sharedb-mingo-memory.svg?branch=master)](https://travis-ci.org/Teamwork/sharedb-mingo-memory)
  [![Coverage Status](https://coveralls.io/repos/github/Teamwork/sharedb-mingo-memory/badge.svg?branch=master)](https://coveralls.io/github/Teamwork/sharedb-mingo-memory?branch=master)

A database adapter for [sharedb](https://github.com/teamwork/sharedb)
that implements a subset of Mongo operations using an in-memory
database. This adapter can be useful for running application tests
faster by not requiring a full database. It is also used by tests for
sharedb itself.

## Usage

```js
var ShareDBMingo = require('@teamwork/sharedb-mingo-memory');
var db = new ShareDBMingo();
```

Another form is useful at times:
`ShareDBMingo.extendMemoryDB(MemoryDB)`.  This creates a new
ShareDBMingo class that extends from a particular MemoryDB class, in
case there are more than one available. This is particularly important
to ensure sharedb tests aren't testing the version of sharedb being
used by sharedb-mingo-memory.

## Queries

sharedb-mingo-memory uses [mingo](https://github.com/kofrasa/mingo)
and supports the same queries mingo supports. In addition, some special
top-level fields are supported, and map to Mongo cursor methods:
* `$orderby` (TODO: rename to `$sort`)
* `$skip`
* `$limit`
* `$count`

Other special operators that are supported in sharedb-mongo such as
`$mapReduce` and `$aggregate` aren't supported and will throw an error
if used.
npm package: @soundation/sharedb-redis-pubsub
Description: Redis pub/sub adapter adapter for ShareDB
Author: Nate Smith
Latest version: 3.1.0

# sharedb-redis-pubsub

  [![NPM Version](https://img.shields.io/npm/v/@teamwork/sharedb-redis-pubsub.svg)](https://npmjs.org/package/@teamwork/sharedb-redis-pubsub)
  [![Build Status](https://travis-ci.org/Teamwork/sharedb-redis-pubsub.svg?branch=master)](https://travis-ci.org/Teamwork/sharedb-redis-pubsub)
  [![Coverage Status](https://coveralls.io/repos/github/Teamwork/sharedb-redis-pubsub/badge.svg?branch=master)](https://coveralls.io/github/Teamwork/sharedb-redis-pubsub?branch=master)

Redis pub/sub adapter adapter for ShareDB.

This ShareDB add-on gives you horizontal scalability; the ability to have a cluster of multiple server nodes rather than just a single server. Using this adapter, clients can connect to any machine in your cluster, and the ops they submit will be forwarded clients connected through other nodes, and there will be no race conditions with regard to persistence.

## Usage

This snippet shows how to load this library and pass it into a new ShareDB instance.

```js
var redisPubsub = require('@teamwork/sharedb-redis-pubsub')(redisClient); // Redis client being an existing redis client connection

var backend = new ShareDB({
  db: db,  // db would be your mongo db or other storage location
  pubsub: redisPubsub
});
```
npm package: @soundboks/appium-device-settings-drivers
Description: Collection of drivers for the settings menus of various devices built for webdriverio.
Author: oss@soundboks.com
Latest version: 0.2.3

# Appium Device Settings Drivers

Collection of drivers for the settings menus of various devices built for webdriverio.


## Usage

The library exports one function `createSettingsDriver` which takes an existing WebdriverIO session, a brand and a platform version and returns an implementation of ISettingsDriver or throws. 


## Supported devices

We currently explicitly support these devices. Note that this generally refers to the latest 1-2 OS versions. Don't expect Android 7 devices to work with these drivers.

- Huawei
- iOS
- LG
- OnePlus
- Samsung
- Stock Android (Google Pixel)


## Device Compatibility, Contributing & Testing

This library is used extensively at SOUNDBOKS for our internal E2E testing and thus is well battle-tested for the devices we test actively, which will generally include the most common vendors and latest OS versions (List to follow). If you have a need to support other devices and want to add a driver, you are free to submit a PR or ask us if we are interested in adding that device to our testing rig and we might.  
  
There is a small test suite included in this repo which covers the use cases that can be covered easily with any well-behaving bluetooth device. There is things not covered in there that we do implement and test internally, such as BT pincodes.  
  
Importantly this is not currently intended to be a feature complete implementation of everything you can access through the settings application. We will generally only implement features that are relevant to end-to-end testing bluetooth devices.
npm package: @soundboks/feurig
Description: A nodejs application-level performance monitoring library
Latest version: 0.5.0

# feurig
A nodejs application-level performance monitoring library

### What? Why?! HOW?!?!

Feurig lets you do application-level monitoring of the runtime of your program, by simply wrapping code you want measured in a call to Feurig.measure. Feurig automatically reconstructs a kind of callstack from the calls to measure and generates a hierarchical timeline of your program. Importantly it is able to maintain that callstack relationship even in heavily asynchronous context. This is all made possible by the async_hooks feature in NodeJS and more specfically AsyncLocalStorage, which allows us to get a kind of "thread-local" for your async execution context. It just works.  

As for why: Because I was amazed noone has done this yet and I need it.

### Usage

Feurig exports one method `measure`. You pass it a callback which is immediately invoked and internally awaited on. You can get the return value of your callback as the first element returned by measure. The second element is a `TimingNode` which represents the entire call-tree that happened within that callback.  
At the very top-level of your project (or where ever you want really) you just wrap your application code in a measure block and save the `TimingNode` to a file. Donezo.

#### Example
```ts
import * as Feurig from "@soundboks/feurig"

async function sleep(ms: number) {
    await new Promise(resolve => setTimeout(resolve, ms))
}

let feurig = Feurig.measure("app", async () => {
    await Promise.all(([2, 7, 0, 1, 8, 2, 7]).map(async e => {
        await Feurig.measure("A and B" + e, async () => {
            await Feurig.measure("A" + e, async () => await sleep(Math.random() * 1000))
            await sleep(Math.random() * 200)
            await Feurig.measure("B" + e, async () => {
                await Feurig.measure("B delay" + e, async () => await sleep(50))
                await sleep(Math.random() * 1000)
            })
        })
    }))
})

feurig.then(([_, timings]) => {
    const output = {
        rootNode: timings,
        start: timings.start,
        end: timings.end,
    }

    writeFile("flame.json", JSON.stringify(output), () => null)
})
```
npm package: @soundboks/nanogrpc
Description: This is a typescript client implementation of the [nanogrpc](../README.md) RPC protocol. It is intended for use with [protobufjs](https://www.npmjs.com/package/protobufjs).
Author: SOUNDBOKS
Latest version: 0.1.1


# NanoGRPC-TS

This is a typescript client implementation of the [nanogrpc](../README.md) RPC protocol.
It is intended for use with [protobufjs](https://www.npmjs.com/package/protobufjs).


## Usage

To use the library, you create a RPC Service Factory. From there you can create services from any [protobufjs](https://www.npmjs.com/package/protobufjs) generated service.

```ts
import * as nanogrpc from "@soundboks/nanogrpc"
import { ExampleService } from "./generated/ExampleService"

const RPCTransport: nanogrpc.RPCTransportAdapter = {
    send: async (request: nanogrpc.RpcPacketRequest) => {
        /// transport implementation
        return response
    }
}

const NanoGRPC = nanogrpc.createRPCServiceFactory(service)

const ExampleService = NanoGRPC.create(ExampleService)

ExampleService.hello().then(console.log)
```


## Transports

To use nanogrpc, you must supply an appropriate transport. The transport must implement the quite simple interface

```ts
export interface RPCTransportAdapter {
    send: (request: RpcPacketRequest) => Promise<RpcPacketResponse>;
}
```

It is important however, that the transport conforms to some implicit assumptions.

### Parallel Service Calls

NanoGRPC does not restrict the capability of any amount of services to make simultaneous requests to multiple services. It is up to the transport to implement queuing mechanisms or whatever resolution strategy is appropriate. A HTTP transport might want to implement parallel requests, while a UART implementation might want to use a mutex.

### Errors

Errors thrown by the transport are propagated through the stack to the consumer. It is expected that if transport fails due to physical layer interruptions or data validity errors, the transport should throw.


### Design Rationale

The interface of the transport adapter is from unencoded RpcPacketRequests to unencoded RpcPacketResponses. This is to allow the transport layer the ability to do deep introspection, if needed to implement complex behaviours, rather than just operating on plain bytes.