open-index/open-npm huggingface dataset:
npm package: @fluffio/core
Description: A lightweight popover/tooltip library with the use of Popover API
Author: geophyzik
Latest version: 1.0.0

## Fluffio

Meet Fluffio: a lightweight tooltip/popover library that utilizes the brand-new Popover API.

> fluffio is currently under development. Please be aware that it has limited number of features and doesn't (yet) work in browsers that don't support Popover API

Fluffio requires two things: an anchor (reference) node, and a popover (tooltip) node


## How To Install?

```shell
npm i @fluffio/core
```

## Usage

Basic usage (show tooltip on hover, positioned at the bottom):

```js
import { fluffio } from '@fluffio/core';

const tooltip = document.querySelector('.tooltip');
const button = document.querySelector('button');

fluffio(tooltip, button);
```

Different placement:
```js
fluffio(tooltip, button, { direction: 'top', side: 'left' })
```

With flipping:
```js
fluffio(tooltip, button, { flip: true })
```

If you need to re-adjust position further on, you can apply computePosition function:

```js
import { fluffio, computePosition } from '@fluffio/core';

const tooltip = document.querySelector('.tooltip');
const button = document.querySelector('button');

fluffio(tooltip, button);

button.addEventListener('click', () => {
  // set direction to top if clicked
  computePosition(tooltip, button, { direction: 'top' });
});
```

## License

MIT
npm package: @fluffy-spoon/csharp-parser
Description: Parses C# code as well as possible into objects in TypeScript.
Latest version: 1.143.0

Parses C# code as well as possible into JavaScript objects.

Are you looking for a flexible C# to TypeScript generator? See: https://github.com/ffMathy/FluffySpoon.JavaScript.CSharpToTypeScriptGenerator
npm package: @fluffy-spoon/csharp-to-typescript-generator.gulp
Description: ```shell npm install --save-dev @fluffy-spoon/csharp-to-typescript-generator.gulp ```
Latest version: 1.32.0

# Installing
```shell
npm install --save-dev @fluffy-spoon/csharp-to-typescript-generator.gulp
```

# Use
```javascript
var gulp = require('gulp');
var poco = require('@fluffy-spoon/csharp-to-typescript-generator.gulp');

gulp.task('poco', function () {
  return gulp
    .src('Models/*.cs')
    .pipe(poco({
      //options go here
    }))
    .pipe(gulp.dest('Scripts'));
});
```

To see what options are available, go here: https://github.com/ffMathy/FluffySpoon.JavaScript.CSharpToTypeScriptGenerator
npm package: @fluffy-spoon/react-globalize
Description: Shared state between components using a useGlobal hook.
Author: ffMathy
Latest version: 1.21.0

[`@fluffy-spoon/react-globalize`](https://www.npmjs.com/package/@fluffy-spoon/react-globalize) is a hook that allows you to share state between components, in a stable and simple manner, without altering React's internal components. 

No magic, just pure simple React. Check the `index.ts` file to see the simplicity of it.

# Example
This library is used for most web API calls on <a href="https://dogger.io">dogger.io</a> right now. Check the Network tab of Chrome there to see that resources are only fetched once when navigating!

# Usage
First, you need to globally create a key for your state, with an optional initial value.

```typescript
//users.ts

import { createGlobalState } from '@fluffy-spoon/react-globalize';

export const usersKey = createGlobalState([{ firstName: "John", lastName: "Doe" }]);
```

Then, you can simply use it in one of your components, just like you would use `useState`!

```typescript
//index.ts

import { usersKey } from './users';

export const GlobalUserListComponent = () => {

    //users and setUsers behaves like useState, except they are now shared between all components!
    const [users, setUsers] = useGlobalState(usersKey);

    ...
}
```

## Using resources
Resources can be helpful for fetching async data only once, and providing controls for refreshing that data.

```typescript
//users.ts

import { createGlobalResource } from '@fluffy-spoon/react-globalize';

export const usersKey = createGlobalResource(async () => 
    await fetch('https://api.example.com/users'));
```

Usage of resources is very similar to global state, and is also only fetched once. However, the 2nd argument is a "control" object which has a `refresh` and a `set` function.

```typescript
//index.ts

import { usersKey } from './users';

export const GlobalUserListComponent = () => {

    const [users, {usersControl}] = useGlobalResource(usersKey);

    //users now refers to the value, fetched only once and shared.
    //usersControl.refresh() will refresh the value.
    //usersControl.set() will set the value to something.

    ...
}
```
npm package: @fluffy-yveltal/ts-gp
Description: CLI de gestion de tâches en TypeScript avec validation, décorateurs et tests.
Author: Gabriel Pied
Latest version: 1.0.1

# TaskScript

CLI de gestion de tâches en TypeScript avec validation, décorateurs et tests.

## Installation
```bash
npm install -g @fluffy-yveltal/ts-gp
```

## Utilisation

### Créer une tâche
```bash
task create "Buy milk" "very important" "Go to Lidl"
```

### Lister les tâches
```bash
taskscript list
```

### Supprimer une tâche
```bash
taskscript delete <id>
```

## Développement
```bash
npm install
npm run build
npm test
npm run test:coverage
```

## Technologies

- TypeScript
- Node.js
- Vitest (tests)
- Strategy Pattern (validation)
- Décorateurs (@timestamp, @validate, @measureTime)

## License

MIT