open-index/open-npm huggingface dataset:
npm package: @matted/esprettify
Description: ESLint and Prettier configurator
Author: Matteo Tedesco
Latest version: 1.0.1

[![GitHub issues](https://img.shields.io/github/issues/M4tT3d/esprettify)](https://github.com/M4tT3d/esprettify/issues) [![GitHub forks](https://img.shields.io/github/forks/M4tT3d/esprettify)](https://github.com/M4tT3d/esprettify/network) [![GitHub stars](https://img.shields.io/github/stars/M4tT3d/esprettify)](https://github.com/M4tT3d/esprettify/stargazers) [![GitHub license](https://img.shields.io/github/license/M4tT3d/esprettify?label=license)](https://github.com/M4tT3d/esprettify/blob/master/LICENSE)

esprettify
npm package: @mattelim/typescript-call-graph
Description: Create a call graph of your TypeScript files (forked from whyboris/TypeScript-Call-Graph)
Author: Matte Lim
Latest version: 0.0.4

![npm](https://img.shields.io/npm/v/typescript-call-graph)

# TypeScript Call Graph

This **CLI** will create an interactive graph of all the functions and their calls in the TypeScript files you provide.

⚠️ this is a work in progress 🚧 more visualizations are coming soon

![image](https://user-images.githubusercontent.com/17264277/85908941-62ba6d00-b7e5-11ea-8e50-2686990aa4f5.png)

## How to use

```sh
npm install -g @mattelim/typescript-call-graph
```

Inside any directory, run:

```sh
tcg
```

It will remind you how to use the CLI: you need to provide specific files, or globs (wildcard paths):

```sh
tcg myFile.ts folder/* anotherFolder/**/*
```

## Developing

Clone repository. Edit `index.ts` and/or `extract.ts` and run `npm start` to build changes, `npm test` to run CLI against files in this repository.

Suggestions or PRs for how to improve this CLI are very welcome 	🙇

You may also edit this repository as you'd like and install your custom version of `tcg` command with `npm run global`

### Thank you

- [Matteo Abrate](https://observablehq.com/@nitaku/tangled-tree-visualization-ii) for the _tangled tree visualization_
- [Mike Bostock](https://observablehq.com/@d3/arc-diagram) for the _arc diagram_
- [GraphViz](https://graphviz.org/), [node-graphviz](https://github.com/glejeune/node-graphviz), and [d3-graphviz](https://github.com/magjac/d3-graphviz) for the simple graph
- [Mermaid-JS](https://github.com/mermaid-js/mermaid) for a way to create a graph
- [Tutorial](https://convincedcoder.com/2019/01/19/Processing-TypeScript-using-TypeScript/) and code for processing TypeScript (AST)
- [Tutorial](https://developer.okta.com/blog/2019/06/18/command-line-app-with-nodejs) for creating a *CLI*
- [TS-Call-Graph](https://github.com/Deskbot/TS-Call-Graph) for inspiration
npm package: @matteo.collina/assets-pg
Description: Manage Assets as a module, with node and postgres
Author: Matteo Collina
Latest version: 4.0.0

# assets-pg

Manage Assets, with node and postgres

An asset can be in three states: `'wait'`, `'operational'` and
`'error'`.

## Install

```
npm install @matteo.collina/assets-pg --save
```

<a name="api"></a>
## API

  * <a href="#assets"><code><b>buildAssets()</b></code></a>
  * <a href="#put"><code>assets.<b>put()</b></code></a>
  * <a href="#get"><code>assets.<b>get()</b></code></a>
  * <a href="#createSchema"><code>assets.<b>createSchema()</b></code></a>
  * <a href="#dropSchema"><code>assets.<b>dropSchema()</b></code></a>

-------------------------------------------------------

<a name="assets"></a>
### buildAssets(connectionString)

The factory for the assets module, you can just pass through a
[pg](http:/npm.im/pg) connection string.

Example:

```js
var connString = 'postgres://localhost/assets_tests'
var assets = require('@matteo.collina/assets-pg')(connString)
```

-------------------------------------------------------

<a name="put"></a>
### assets.put(object, callback(err, asset))

Adds or updates an asset. An asset can have three properties:

1. the `'id'`, which needs to be set only for existing assets
2. the `'name'`
3. the `'status'`, which can be any of
   `'wait'`, `'operational'` and `'error'`.

Validation is provided by [ajv](http://npm.im/ajv), and a `new
createError.UnprocessableEntity()` (from [http-errors](https://www.npmjs.com/package/http-errors))
with the ajv errors attached to the `details`.

The returned asset includes the `id`, if missing.

-------------------------------------------------------

<a name="get"></a>
### assets.get(id, callback(err, asset))

Fetches an assets, returns a
`new createError.NotFound()` (from [http-errors](https://www.npmjs.com/package/http-errors))
if not present.

-------------------------------------------------------

<a name="createSchema"></a>
### assets.createSchema(callback(err))

Create the schema in PostgreSQL for this module.

-------------------------------------------------------

<a name="dropSchema"></a>
### assets.dropSchema(callback(err))

Drop the schema in PostgreSQL for this module.

-------------------------------------------------------

<a name="end"></a>
### assets.end()

Ends the PG connection pool.

## License

MIT
npm package: @matteo.collina/cocktail-control
Description: Control you cocktail robot
Author: Matteo Collina
Latest version: 1.3.0

# cocktail-control&nbsp;&nbsp;[![Build Status](https://travis-ci.org/mcollina/cocktail-control.png)](https://travis-ci.org/mcollina/cocktail-control)

The control logic for some bots that makes cocktail

## Install

```
npm i level @matteo.collina/cocktail-control --save
```

## Example

```js
var level = require('level')
var control = require('@matteo.collina/cocktail-control')
var cocktails = {
  bloody: {
    activations: [
      20, // milleseconds
      10,
      50
    ]
  },
  spritz: {
    activations: [
      10, // milleseconds
      20,
      30
    ]
  }
}
var defs = {
  cocktails: cocktails,
  workers: {
    bob: {
      cocktails: ['bloody', 'spritz']
    },
    mark: {
      cocktails: ['spritz', 'spritz']
    }
  }
}

// the leveldb is used for persitence
var db = level(dir.name)
var robot = control(db, defs)

// enqueue also accepts a callback
robot.enqueue({
  cocktail: 'spritz',
  name: 'Matteo'
}).enqueue({
  cocktail: 'spritz',
  name: 'Cian'
}).enqueue({
  cocktail: 'spritz',
  name: 'Tammy'
}).enqueue({
  cocktail: 'bloody',
  name: 'David'
}).enqueue({
  cocktail: 'bloody',
  name: 'Richard'
})

robot.on('bob', function (cocktails) {
  console.log('bob making', cocktails)

  // this would be async in the real world
  setImmediate(robot.free.bind(robot, 'bob'))
})

robot.on('mark', function (cocktails) {
  console.log('mark making', cocktails)

  // this would be async in the real world
  setImmediate(robot.free.bind(robot, 'mark'))
})

// kick off processing of cocktails
robot.free('bob') // let says that bob is free
robot.free('mark') // let says that mark is free
```

## Acknowledgements

This library was built for [NodeConf.eu](http://nodeconf.eu), and it was
sponsored by [nearForm](http://nearform.com)

## License

MIT
npm package: @matteo.collina/fastify-auth-mongo-jwt
Description: Sample user-management (signup, login) with Fastify and JWT
Author: Matteo Collina
Latest version: 0.2.0

# fastify-auth-mongo-jwt

Sample user-management (signup, login) with Fastify and JWT, on top of
[MongoDB](https://www.mongodb.com).

This plugin sends credentials in plain text, and it implies that
HTTPS is used to protect the application.

## Install

```
npm i @matteo.collina/fastify-auth-mongo-jwt
```

## Usage

```js
'use strict'

const Fastify = require('fastify')
const AuthMongoJwt = require('@matteo.collina/fastify-auth-mongo-jwt')

const app = Fastify()

app.register(AuthMongoJwt, {
  auth: {
    secret: 'thisisalongsecretjustfortests'
  },
  mongodb: {
    url: 'mongodb://mongo/mydb',
    w: 1,
    useNewUrlParser: true
  }
})

app.register(async function (app, opts) {
  app.addHook('preHandler', function (req, reply) {
    return req.jwtVerify()
  })

  app.get('/username', async function (req, reply) {
    return req.user.username
  })
}, { prefix: '/protected' })
```

## REST routes

This fastify plugin offers the following routes.

### POST /signup

Accepts the following body:

```json
{
  "username": 'a unique thing',
  "password": 'a long password'
}
```

It will return a JWT token, encapsulated with an object:

```json
{
  "status": 'ok',
  "token": 'a jwt token'
}
```

### GET /me

Requires the `Authorization: Bearer TOKEN` header.
Returns the current user if the token is valid

```json
{
  "username": 'a unique thing'
}
```

### POST LOGIN

Accepts the following body:

```json
{
  "username": 'a unique thing',
  "password": 'a long password'
}
```

It will return a JWT token, encapsulated with an object:

```json
{
  "status": 'ok',
  "token": 'a jwt token'
}
```

## API

It adds the same decorators of
[fastify-jwt](https://github.com/fastify/fastify-jwt).

### createUser(app, { username, password })

Utility function to help writing unit tests against this module. It
returns a JWT `token` for the given user and an `inject` function to
call HTTP endpoint with that token.

Example:

```js
const Fastify = require('fastify')
const AuthMongoJwt = require('@matteo.collina/fastify-auth-mongo-jwt')
const { createUser } = AuthMongoJwt

async function run () {
  const app = Fastify({
    logger: {
      level: 'error'
    }
  })

  app.register(AuthMongoJwt, {
    auth: {
      secret: 'thisisalongsecretjustfortests'
    },
    mongodb: {
      url: 'mongodb://mongo/mydb',
      w: 1,
      useNewUrlParser: true
    }
  })

  app.register(async function (app, opts) {
    app.addHook('preValidation', function (req, reply) {
      return req.jwtVerify()
    })

    app.get('/username', async function (req, reply) {
      return req.user.username
    })
  }, { prefix: '/protected' })

  const {
    token, // this is the JWT token
    inject // utility function to inject with that token
  } = await createUser(app)

  const res = await inject({
    url: '/username',
    method: 'GET'
  })

  console.log(JSON.parse(res.body))
}

run()
```

## License

MIT
npm package: @matteo.collina/fastify-mongo-tickets
Description: Demo ticket service with Fastify and MongoDB
Author: Matteo Collina
Latest version: 0.3.1

# fastify-mongo-tickets

Demo ticket service with Fastify and MongoDB

## Install

```
npm i @matteo.collina/fastify-mongo-tickets
```

## Usage

```js
'use strict'

const Fastify = require('fastify')

const app = Fastify()

app.register(require('fastify-jwt'), {
  secret: 'averyverylongsecret'
})

app.register(require('fastify-mongodb'), {
  url: 'mongodb://localhost:27017',
  useNewUrlParser: true
})

app.register(require('@matteo.collina/fastify-mongo-tickets'))

app.listen(3000)
```

Works best in combo with
[https://github.com/mcollina/fastify-auth-mongo-jwt](https://github.com/mcollina/fastify-auth-mongo-jwt).

## API

Docs TBD, see tests.
It uses [fastify-mongodb](https://github.com/fastify-mongodb) and [fastify-jwt](https://github.com/fastify-jwt)

## License

MIT
npm package: @matteo.collina/minimist
Description: parse argument options
Author: James Halliday
Latest version: 2.0.0

# minimist

parse argument options

This module is the guts of optimist's argument parser without all the
fanciful decoration.

# example

``` js
var argv = require('@matteo.collina/minimist')(process.argv.slice(2));
console.log(argv);
```

```
$ node example/parse.js -a beep -b boop
{ _: [], a: 'beep', b: 'boop' }
```

```
$ node example/parse.js -x 3 -y 4 -n5 -abc --beep=boop foo bar baz
{ _: [ 'foo', 'bar', 'baz' ],
  x: 3,
  y: 4,
  n: 5,
  a: true,
  b: true,
  c: true,
  beep: 'boop' }
```

# security

Previous versions had a prototype pollution bug that could cause privilege
escalation in some circumstances when handling untrusted user input.

Please use version 1.2.6 or later:

* https://security.snyk.io/vuln/SNYK-JS-MINIMIST-2429795 (version <=1.2.5)
* https://snyk.io/vuln/SNYK-JS-MINIMIST-559764 (version <=1.2.3)

# methods

``` js
var parseArgs = require('minimist')
```

## var argv = parseArgs(args, opts={})

Return an argument object `argv` populated with the array arguments from `args`.

`argv._` contains all the arguments that didn't have an option associated with
them.

Numeric-looking arguments will be returned as numbers unless `opts.string` or
`opts.boolean` is set for that argument name.

Any arguments after `'--'` will not be parsed and will end up in `argv._`.

options can be:

* `opts.string` - a string or array of strings argument names to always treat as
strings
* `opts.boolean` - a boolean, string or array of strings to always treat as
booleans. if `true` will treat all double hyphenated arguments without equal signs
as boolean (e.g. affects `--foo`, not `-f` or `--foo=bar`)
* `opts.alias` - an object mapping string names to strings or arrays of string
argument names to use as aliases
* `opts.default` - an object mapping string argument names to default values
* `opts.stopEarly` - when true, populate `argv._` with everything after the
first non-option
* `opts['--']` - when true, populate `argv._` with everything before the `--`
and `argv['--']` with everything after the `--`. Here's an example:

  ```
  > require('./')('one two three -- four five --six'.split(' '), { '--': true })
  { _: [ 'one', 'two', 'three' ],
    '--': [ 'four', 'five', '--six' ] }
  ```

  Note that with `opts['--']` set, parsing for arguments still stops after the
  `--`.

* `opts.unknown` - a function which is invoked with a command line parameter not
defined in the `opts` configuration object. If the function returns `false`, the
unknown option is not added to `argv`.

# install

With [npm](https://npmjs.org) do:

```
npm install @matteo.collina/minimist
```

# license

MIT
npm package: @matteo.collina/p
Description: Fast promise utilities
Author: Matteo Collina
Latest version: 0.1.1

# fastp

Fast promise utilities

## Install

```js
npm i @matteo.collina/p
```

## API

### `p.limit(concurrency=1)`

Limit the number of promises resolved concurrently.
Offers the same API of [p-limit](http://npm.im/p-limit)

```js
import p from 'fastp'
import { settimeout as sleep } from 'node:timers/promises'
const limit = p.limit(2);

const result1 = await Promise.all([
	limit(() => sleep(300, 'foo')),
	limit(() => sleep(200, 'bar')),
	limit(() => sleep(100, 'baz'))
]);
console.log(result1)
// [ 'foo', 'bar', 'baz' ]

const result2 = await Promise.race([
	limit(() => sleep(300, 'foo')),
	limit(() => sleep(200, 'bar')),
	limit(() => sleep(100, 'baz'))
]);
console.log(result2)
// 'bar'
```

It's over 3x faster than `p-limit`  

```
╔══════════════╤═════════╤═════════════════╤═══════════╗
║ Slower tests │ Samples │          Result │ Tolerance ║
╟──────────────┼─────────┼─────────────────┼───────────╢
║ pLimit       │   10000 │ 24994.77 op/sec │  ± 3.08 % ║
╟──────────────┼─────────┼─────────────────┼───────────╢
║ Fastest test │ Samples │          Result │ Tolerance ║
╟──────────────┼─────────┼─────────────────┼───────────╢
║ fastp.limit  │   10000 │ 91958.28 op/sec │  ± 5.76 % ║
╚══════════════╧═════════╧═════════════════╧═══════════╝
```

## License

MIT
npm package: @matteo.collina/release-notes
Description: How I create release notes for my npm modules
Author: Matteo Collina
Latest version: 0.7.0

# release-notes

How I create release notes for my npm modules

## Install

```
npm i @matteo.collina/release-notes
```

## Usage

```
release-notes -a $GITHUB_ACCESS_TOKEN -o mcollina -r test-releases -t v0.0.4
```

We recommend the use of a granular github access token
or a token provided by GitHub Actions.

## License

MIT
npm package: @matteo.collina/snap
Description: snapshot testing companion for node:test
Author: Matteo Collina
Latest version: 1.0.0

# @matteo.collina/snap

snapshot testing companion for node:test.

## Install

```
npm i @matteo.collina/snap
```

## Usage

```js
import Snap from '@matteo.collina/snap'
import { test } from 'node:test'
import { deepEqual } from 'node:assert/strict'

const snap = Snap(import.meta.url)

test('a snapshot', async (t) => {
  const actual = await (await fetch('http://example.com')).text()
  const snapshot = await snap(actual)
  deepEqual(actual, snapshot)
})
```

On the first execution, the snapshot will be taked and stored in
the `.snapshots` folder in the same directory of `package.json`.

To update the snapshot, run with the `SNAP_UPDATE=1` env variable set.

### Usage with CommonJS

```js
const Snap = require('@matteo.collina/snap')
const { test } = require('node:test')
const { deepEqual } = require('node:assert/strict')

const snap = Snap(__filename)

test('a snapshot', async (t) => {
  const actual = await (await fetch('http://example.com')).text()
  const snapshot = await snap(actual)
  deepEqual(actual, snapshot)
})
```

## License

MIT
npm package: @matteo.collina/timeseries-pg
Description: Manage a timeseries using a module, with node and postgres
Author: Matteo Collina
Latest version: 3.0.0

# timeseries-pg

Manage timeseries, with node and postgres

An datapoint can be in three states: `'wait'`, `'operational'` and
`'error'`.

## Install

```
npm install @matteo.collina/timeseries-pg --save
```

<a name="api"></a>
## API

  * <a href="#timeseries"><code><b>buildTimeseries()</b></code></a>
  * <a href="#put"><code>timeseries.<b>put()</b></code></a>
  * <a
    href="#createReadStream"><code>timeseries.<b>createReadStream()</b></code></a>
  * <a href="#createSchema"><code>timeseries.<b>createSchema()</b></code></a>
  * <a href="#dropSchema"><code>timeseries.<b>dropSchema()</b></code></a>

-------------------------------------------------------

<a name="timeseries"></a>
### buildtimeseries(connectionString)

The factory for the timeseries module, you can just pass through a
[pg](http:/npm.im/pg) connection string.

Example:

```js
var connString = 'postgres://localhost/timeseries_tests'
var timeseries = require('@matteo.collina/timeseries-pg')(connString)
```

-------------------------------------------------------

<a name="put"></a>
### timeseries.put(object, callback(err, datapoint))

Adds or updates an datapoint. An datapoint can have three properties:

1. the `'id'`, which needs to be set only for existing datapoints
2. the `'asset'`, the asset from which this datapoint was acquired
3. the `'value'`, a double that is the core of the datapoint
4. the `'timestamp'`, which defaults to `Date.now()`

Validation is provided by [Joi](http://npm.im/joi), and a Joi error
object will be provided in case of validation errors.

The returned datapoint includes the `id` and `timestamp`, if missing.

-------------------------------------------------------

<a name="createReadStream"></a>
### timeseries.createReadStream(opts)

Returns a
[Readable Stream](https://nodejs.org/api/stream.html#stream_class_stream_readable) that returns the data points.

Acceptable options are:

* `asset`: specify the asset that generated the datapoint
* `from`: the minimum timestamp that will be considered, it must be a `Date` object
* `to`: the maximum timestamp that will be considered, it must be a `Date` object

-------------------------------------------------------

<a name="createSchema"></a>
### timeseries.createSchema(callback(err))

Create the schema in PostgreSQL for this module.

-------------------------------------------------------

<a name="dropSchema"></a>
### timeseries.dropSchema(callback(err))

Drop the schema in PostgreSQL for this module.

## License

MIT
npm package: @matteo.collina/tspl
Description: Count the number of assertions for node:test
Author: Matteo Collina
Latest version: 0.2.0

# tspl

Test Planner for [`node:test`](https://nodejs.org/api/test.html)
and [`node:assert`](https://nodejs.org/api/assert.html).
It fails your tests if the number of assertions is not met,
or the test plan was not completed.

## Installation

```bash
npm i @matteo.collina/tspl --save-dev
```

(You'll also need `@types/node`)

## Example

```js
import test from 'node:test';
import { tspl } from '@matteo.collina/tspl';

test('tspl', (t) => {
  const { strictEqual } = tspl(t, { plan: 1 });
  strictEqual(1, 1);
});
```

### Typescript

```typescript
import test from 'node:test';
import { tspl, type Plan } from '@matteo.collina/tspl';

test('tspl', (t) => {
  const p: Plan = tspl(t, { plan: 1 });
  p.strictEqual(1, 1);
});
```

## API

### __`tspl(t: TestContext, options): Plan`__

Create a plan for the current test.

Here are the options:

* `plan`: how many assertions are planned

### `Plan`

The plan includes all exports from [`node:assert`](https://nodejs.org/api/assert.html),
as well as:

* `end()`: a function to complete the plan
* `completed`: a promise that will resolve when the plan is completed.

## License

MIT
npm package: @matteo.collina/users-pg
Description: Manage Users as a module, with node and postgres
Author: Matteo Collina
Latest version: 3.0.0

# users-pg

Manage Users, with node and postgres

## Install

```
npm install @matteo.collina/users-pg --save
```

<a name="api"></a>
## API

  * <a href="#users"><code><b>buildUsers()</b></code></a>
  * <a href="#put"><code>users.<b>put()</b></code></a>
  * <a href="#get"><code>users.<b>get()</b></code></a>
  * <a href="#authenticate"><code>users.<b>authenticate()</b></code></a>
  * <a href="#createSchema"><code>users.<b>createSchema()</b></code></a>
  * <a href="#dropSchema"><code>users.<b>dropSchema()</b></code></a>

-------------------------------------------------------

<a name="users"></a>
### buildusers(connectionString)

The factory for the users module, you can just pass through a
[pg](http:/npm.im/pg) connection string.

Example:

```js
var connString = 'postgres://localhost/users_tests'
var users = require('@matteo.collina/users-pg')(connString)
```

-------------------------------------------------------

<a name="put"></a>
### users.put(object, callback(err, user))

Adds or updates an user. An user can have three properties:

1. the `'id'`, which needs to be set only for existing users
2. the `'username'`
3. the `'status'`, which can be any of
   `'wait'`, `'operational'` and `'error'`.

Validation is provided by [Joi](http://npm.im/joi), and a Joi error
object will be provided in case of validation errors.

The returned user includes the `id`, if missing.

-------------------------------------------------------

<a name="get"></a>
### users.get(id, callback(err, user))

Fetches an users, returns a
[`boom.notFound`](https://www.npmjs.com/package/boom#boom-notfound-message-data)
if not present.

-------------------------------------------------------

<a name="authenticate"></a>
### users.authenticate(user, callback(err, result, user))

Fetches a user, hashes the password with the stored salt and matches it
against the database. `result` is `true` if the match is successful,
`false` otherwise.
Returns [`boom.notFound`](https://www.npmjs.com/package/boom#boom-notfound-message-data)
if not present.

-------------------------------------------------------

<a name="createSchema"></a>
### users.createSchema(callback(err))

Create the schema in PostgreSQL for this module.

-------------------------------------------------------

<a name="dropSchema"></a>
### users.dropSchema(callback(err))

Drop the schema in PostgreSQL for this module.

## License

MIT
npm package: @matteoaliano/feedati-figjam-plugin
Description: FigJam plugin to import Feedati insights as sticky notes from Supabase
Author: Matteo Aliano
Latest version: 1.0.1

# Feedati FigJam Plugin

Import Feedati insights as sticky notes directly into FigJam boards. Stickies are color-coded by category or priority, with configurable layout and content options.

## Installation

```bash
npm install @matteoaliano/feedati-figjam-plugin
```

## Setup in Figma

1. Open **Figma Desktop** (the plugin requires the desktop app)
2. Go to **Plugins** > **Development** > **Import plugin from manifest...**
3. Navigate to your project's `node_modules/@matteoaliano/feedati-figjam-plugin/manifest.json` and select it
4. The plugin is now available in your FigJam boards

## Usage

1. Open a **FigJam board** (the plugin only works in FigJam, not Figma Design)
2. Right-click the canvas > **Plugins** > **Development** > **Feedati FigJam Plugin**
3. The plugin will automatically connect and load all available insights

### Filtering

Use the filter dropdowns to narrow down which insights become stickies:

- **Category** — Bug, Enhancement, New Feature, Upsell, Other
- **Priority** — Critical, High, Medium, Low
- **Status** — New, In Progress, Resolved, Sold, Archived
- **Client** — Populated from your data

The counter below the filters shows how many insights match.

### Layout Options

| Option | Choices | Default |
|--------|---------|---------|
| Layout | Grouped by Category / Grid | Grouped |
| Sticky Size | Small / Medium / Large | Medium |
| Color By | Category / Priority | Category |
| Show on Sticky | Summary, Client, Priority | All checked |

### Creating Stickies

Click **Create Stickies** to place them on the board. The viewport will automatically zoom to fit the created stickies.

- **Grouped layout** creates sections per category with labeled headers
- **Grid layout** places stickies in a simple row/column grid

### Color Mapping

**By Category:**
| Category | Color |
|----------|-------|
| Bug | Red |
| Enhancement | Purple |
| New Feature | Blue |
| Upsell | Green |
| Other | Gray |

**By Priority:**
| Priority | Color |
|----------|-------|
| Critical | Red |
| High | Orange |
| Medium | Yellow |
| Low | Gray |

## Troubleshooting

| Issue | Solution |
|-------|----------|
| Plugin not visible | Ensure you're in a **FigJam** board, not a Figma Design file |
| "Missing Supabase credentials" | The build may be corrupted — reinstall the package |
| "Failed to fetch" | Check your network connection; the plugin needs access to `*.supabase.co` |
| No insights loading | Verify your Supabase `insights` table has data |

## Requirements

- Figma Desktop app (browser version does not support development plugins)
- Network access to `*.supabase.co`
npm package: @matteoaliano/forest-ui
Description: Forest Design System — themed MUI components
Latest version: 0.5.2

# Forest UI

Forest Design System — A multi-tenant MUI v7 + Emotion component library.

## Installation

```bash
npm install @matteoaliano/forest-ui
```

## Quick Start

```tsx
import { ForestProvider, Button, Typography } from '@matteoaliano/forest-ui';
import '@fontsource/poppins'; // or load Aeonik font

function App() {
  return (
    <ForestProvider>
      <Typography variant="h1">Hello Forest</Typography>
      <Button variant="contained">Click me</Button>
    </ForestProvider>
  );
}
```

## Theme Presets

Three presets are available:

| Preset | Use Case |
|--------|----------|
| `forest-agency` | Internal tools + partner agencies (default) |
| `forest-external` | Client-facing products |
| `forest-internal` | Internal tools |

### Using a Preset

```tsx
import { ForestProvider } from '@matteoaliano/forest-ui';

<ForestProvider preset="forest-external">
  {/* Your app */}
</ForestProvider>
```

### Using a Custom Theme

```tsx
import { ForestProvider, buildTheme } from '@matteoaliano/forest-ui';
import { getPreset } from '@matteoaliano/forest-ui';

const preset = getPreset('forest-agency');
const theme = buildTheme(preset.variants.light.tokens);

<ForestProvider theme={theme}>
  {/* Your app */}
</ForestProvider>
```

## Components

40+ wrapped MUI components with Forest defaults. See [Storybook](https://storybook.url) for all components.

### Inputs
- Button, ButtonGroup
- TextField, Select, MultiSelect
- Checkbox, RadioGroup, Switch
- ToggleButton
- DatePicker
- Autocomplete
- Search

### Data Display
- Typography
- Table, DataGrid
- Chip, Badge
- Tooltip
- List
- Divider
- Skeleton

### Surfaces
- Card, Paper
- AppBar
- Accordion

### Feedback
- Alert, Snackbar
- Dialog, Modal, Popover
- Progress (Linear, Circular)
- Backdrop

### Navigation
- Tabs, Stepper
- Pagination
- Breadcrumbs
- Link
- Menu
- SidebarNav

### Charts
- LineChart, BarChart, PieChart

## Development

```bash
# Install dependencies
npm install

# Build
npm run build

# Run tests
npm test

# Storybook
npm run storybook
```

## License

MIT
npm package: @matteob10/modal-react
Description: React modal component using native <dialog> with backdrop click, Escape handling and close button.
Author: matteob10
Latest version: 1.0.1

# @matteob10/modal-react

Reusable React modal component built on the native HTML <dialog> element.
This component provides a simple and accessible solution to display modal dialogs in React applications.

---

## Prerequisites

Node.js >= 18
npm >= 10
React 18 or 19
react-dom 18 or 19
styled-components >= 6

---

## Installation

Install the package from npm:

npm install @matteob10/modal-react


This package uses peer dependencies. Make sure the following are installed in your project:

npm install react react-dom styled-components

---

## Example of use

```jsx
import { useState } from "react";
import { Modal } from "@matteob10/modal-react";

function Example() {
  const [open, setOpen] = useState(false);

  return (
    <>
      <button onClick={() => setOpen(true)}>Open modal</button>

      <Modal open={open} onClose={() => setOpen(false)}>
        <p>Hello from the modal</p>
      </Modal>
    </>
  );
}

export default Example;

```
---

## Props

open (boolean)
Controls whether the modal dialog is open or closed.

onClose (function)
Callback function triggered when the modal requests to close
(Escape key press, backdrop click, or close button click).

children (ReactNode)
Content rendered inside the modal dialog.

---

## License

MIT License

---

## Author

© 2025 matteob10
npm package: @matteobax/date-convalidator
Description: Check the validity of the date
Author: matteobax
Latest version: 2.0.2


# date-convalidator

This tool allows you to check if a date is entered correctly



## Usage

```javascript
const convalidate = require('@matteobax/date-convalidator');
let date=''; // The date to check (separators - / . can be used)
let format = '' // The format of date (dd/mm/yyyy , yyyy/mm/dd , mm/dd/yyyy)
let check = convalidate.checkDate(date, format);
if(check==0){
    console.log('correct date');
}else if (check==-1){
    console.log('wrong date');
}
```

## Installation

```
npm i @matteobax/date-convalidator
```
npm package: @matteobortolazzo/fast-morph
Description: A fast Morphing UI web component
Author: Matteo Bortolazzo
Latest version: 1.1.0

# Fast Morph

**A Morphing UI web component built with StencilJS**

Inspired by brunnolou's [react-morph](https://github.com/brunnolou/react-morph)

![Sign-In example](https://raw.githubusercontent.com/matteobortolazzo/fast-morph/master/gifs/motion-ui-sign-in.gif)


## Install
```
npm i @matteobortolazzo/fast-morph --save
```

**Stencil project**
```
// stencil.config.js
exports.config = {
  ...
  collections: [
    { name: '@matteobortolazzo/fast-morph' }
  ]
}
```

**Pure HTML**
```
<script src="https://unpkg.com/@matteobortolazzo/fast-morph@1.0.1/dist/fast-morph.js"></script> 
```

**Angular / React**

Please visit [https://stenciljs.com/docs/framework-integration](https://stenciljs.com/docs/framework-integration)


## Example

1. Create two states (HTML)
2. Wrap both in one fast-morph component (using slot="state-0" and slot="state-1")
3. Label the elements you want to morph with itemprop="fm-\<something\>"
4. Label the elements you want to use to change state with itemprop="fm-activator"

```html
<fast-morph>
    <div slot="state-0">
      <div itemprop="fm-activator" class="state-0-div">
        <div itemprop="fm-sign-in-back" class="sign-in-back"></div>
        <div itemprop="fm-sign-in">Sign In</div>
      </div>
    </div>
    <div slot="state-1">
      <div class="form-container">
        <div class="form-back" itemprop="fm-sign-in-back"></div>
        <form>
          <div class="label">Email</div>
          <input />
          <div class="label password">Password</div>
          <input />
          <br />
          <div itemprop="fm-sign-in" class="sign-in">Sign In</div>
          <div class="cancel" itemprop="fm-activator">Cancel</div>
        </form>
      </div>
    </div>
  </fast-morph>
```

## Keep in mind
(this section is from [**brunnolou**'s react-morph](https://github.com/brunnolou/react-morph))

* You need to remove extra whitespace, to match the real element's width, the solution is display: inline-block or a wrapping element to the content.
* Margins are always tricky because they create extra white space. You can either wrap the content in another element and animate it or be sure to match both the margins in both states.
* Sometimes it's necessary to create a placeholder element for the transition to avoid child distortion.
* List items could be miscalculated; a simple solution is: list-style: none;.
* Sometimes you need extra layers instead of nested children.
* Avoid animating both the parent and children to avoid unpredicted results.

![Card example](https://raw.githubusercontent.com/matteobortolazzo/fast-morph/master/gifs/motion-ui-card.gif)
npm package: @matteocacciola/sentiment
Description: Collection of functions for sentiment analysis
Author: Matteo Cacciola
Latest version: 1.4.1

# Sentiment Analysis for Node.js

[![Coverage Status](https://coveralls.io/repos/github/matteocacciola/sentiment/badge.svg?branch=v1.4.1)](https://coveralls.io/github/matteocacciola/sentiment?branch=v1.4.1)

This library aims to provide a support for the analysis of texts, like the evaluation of Sentiment or Text Matching.
Please, consult the various methods here provided in order to have a wide overview of the possible features.

- [Media Sentiment Analysis](./docs/media-sentiment.md)
- [Texts Sentiment Analysis](./docs/texts-sentiment.md)
- [Texts Sentiment Analysis based on Keywords and Text Similarities](./docs/keywords-sentiment.md)
- [Text Matching based on Sentiment Analysis](./docs/text-matching.md)
- [Text Similarities](./docs/text-similarities.md)

## Installation
In order to install the library, please use
```
npm i @matteocacciola/sentiment
```

## Notes
The available methods allow to use evaluations of Sentiment and scores by means of predefined strategies, already
implemented within this package, or by using a custom and self-implemented Sentiment classifier, e.g. obtained by
training suitable Machine Learning structures.
If you want to consult possible algorithms you can train, please feel free to be inspired by my
[Machine Learning codes](https://github.com/matteocacciola/challenges/tree/master/machine-learning/src) like Support
Vector Machines, Convolutional Neural Network, Multilayer Perceptron Artificial Neural Network, Fuzzy C-means and so forth.
npm package: @matteocodogno/eslint-config
Description: WellD's ESLint config, following our styleguide
Author: Matteo Codogno
Latest version: 1.0.3

# WellD's eslint configuration

This repository contains ESLint configuration for WellD's projects.

## Getting Started

Install the package through your package manager of choice:

```
yarn add -D @welld/eslint-config
```

Install the necessary peer dependencies. You can list and install them manually by running:

```
npm info "@welld/eslint-config@latest" peerDependencies
```

Or you can run

```
npx install-peerdeps --dev @welld/eslint-config
```

`install-peerdeps` will take care of installing the peer dependencies for you (and will also detect Yarn if the project is using it).

There are four configurations available:

1. Plain JavaScript projects: extend `@welld/eslint-config/js`;
2. JavaScript and React projects: extend `@welld/eslint-config/js-react`;
3. Plain TypeScript projects: extend `@welld/eslint-config/ts`;
4. TypeScript and React projects: extend `@welld/eslint-config/ts-react`.

### Prerequisites

- node
- yarn

### Installing

Dependencies for the project can be installed through `yarn install`.

## Development

[Here](https://eslint.org/docs/developer-guide/shareable-configs) you can find the documentation on how to create a ESLint shareable config.

You could edit a ESLint configuration and then test it on a _test_ project.

```shell script
npm link
```

Then in the _test_ project, type:

```shell script
npm link eslint-config-welld
```

## Built With

- [ESLint](https://eslint.org/) - Find and fix problems in your JavaScript code
- ESLint [airbnb](https://github.com/airbnb/javascript) config

## Contributing

Please read [CONTRIBUTING.md](./CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests to us.

## Versioning

We use SemVer for versioning. For the versions available, see the tags on this repository.

## Authors

Matteo Codogno - Initial work

## License

Look [here](./LICENSE)
npm package: @matteofabio/react-semantic-search
Description: search from a list of items
Author: rockson
Latest version: 1.0.11
Deprecated: deprecated

# Search items in an array

## Install
```
npm i -S @matteofabio/react-semantic-search
```

## Example
```jsx
import Search from '@matteofabio/react-semantic-search'
import React from 'react';
import { Sidebar, Menu } from 'semantic-ui-react';
import 'semantic-ui-css/semantic.css'

const items = [
  {
    id: 0,
    title: 'Ordini',
    icon: 'cart',
    to: '/OrdersList',
  },
  {
    id: 1,
    title: 'Albero Genealogico Agenti',
    icon: 'tree',
    to: '/TreeAgents',
  },
  {
    id: 2,
    title: 'Dati Agente',
    icon: 'address card outline',
    to: '/privacy/:id',
  },
];

<Sidebar as={Menu} animation="overlay" visible vertical inverted>
    <Search
    items={items}
    onSelectItem={(item) => console.log(item)}
    mainText="title"
    />
</Sidebar>
```