open-index/open-npm huggingface dataset:
npm package: @sum.services/form.io.gis
Description: Contrib components for form.io use by SGIS project
Author: Travis Tidwell
Latest version: 1.0.0

# Form.io contrib components library

This module contains contributed components for use with Form.io. It also serves as a good example on how you can
create your very own custom components library that can be used with Form.io platform.

## Installation
To install this library, do the following.

```
npm install --save @formio/contrib
```

## Usage

```javascript
import { Formio } from 'formiojs';
import FormioContrib from '@formio/contrib';
Formio.use(FormioContrib);
```

You can also include this library within the DOM of your application like the following.

```html
<link rel="stylesheet" href="https://unpkg.com/formiojs@latest/dist/formio.full.min.css">
<script src="https://unpkg.com/formiojs@latest/dist/formio.full.min.js"></script>
<script src="https://unpkg.com/@formio/contrib@latest/dist/formio-contrib.min.js"></script>
<link rel="stylesheet" href="https://unpkg.com/@formio/contrib@latest/dist/formio-contrib.css">
<script type="text/javascript">
    Formio.use(FormioContrib);
</script>
```

Or you can use the **formio-contrib.use.min.js** file which automatically adds the ```Formio.use``` method.

```html
<link rel="stylesheet" href="https://unpkg.com/formiojs@latest/dist/formio.full.min.css">
<script src="https://unpkg.com/formiojs@latest/dist/formio.full.min.js"></script>
<script src="https://unpkg.com/@formio/contrib@latest/dist/formio-contrib.use.min.js"></script>
<link rel="stylesheet" href="https://unpkg.com/@formio/contrib@latest/dist/formio-contrib.css">
```

### Using within the Form.io Developer Portal
It is also possible to inject custom components within the Form.io Developer Portal. This allows you to use the Developer Portal to create forms that include your custom components. Note: This currently only works with the Next portal @ https://next.form.io

To make this work, navigate to your project settings, and then click on **Custom JS and CSS**. Within the **Custom JavaScript** box, you will then place the hosted URL to the **dist/formio-contrib.use.min.js** file within this library, like so.

![](https://api.monosnap.com/file/download?id=dQmYlhPWLa7mDDDJMN1VpkJwXy7iHG)

You can also use the unpkg url to this repo to test this out. [https://unpkg.com/@formio/contrib@latest/dist/formio-contrib.use.min.js](https://unpkg.com/@formio/contrib@latest/dist/formio-contrib.use.min.js)

### Using within the Form Manager application
You can also use this method to introduce custom components into the Form Manager application. To get this to work, you just need to Enable Public configurations within your project settings, and then provide the **js** setting to contain the URL of the **dist/formio-contrib.use.min.js** file within this repository like so.

![](https://api.monosnap.com/file/download?id=lvK2kW9eOuAEVDMNW96hP5qLOCaQEY)
npm package: @sum_sum/mini-templating
Description: A simple templating/reactive-elements helper for low code web pages
Author: Tomás Marques
Latest version: 1.1.3

# Mini Templating

## What does this do?

Provide a way to emulate a reactive/template based js-framework experience,
in a similar but more reduced and simplified manner.

## Features

**Currently implemented:**

- Reactivity - Elements listen for changes in page content and update accordingly.

**To be implemented:**


- Components/Templating - Create reduced/separated html files for ease of use

- List of TODOS [here](/Todos.md)

## Syntax & Usage helper

You can learn more about the syntax [here](/Mini%20Template%20Syntax.md)
npm package: @suman-jangili/privacy-first-client
Description: A privacy‑first client built with React + TypeScript + Vite
Author: Suman Jangili
Latest version: 0.1.9

📄 `privacy‑first‑client`

## @suman-jangili/privacy‑first‑client
A **privacy‑first** front‑end demo built with **React**, **TypeScript**, and **Vite**.  
It showcases how to use `libsodium-wrappers` in the browser for end‑to‑end encryption while communicating with the companion server package (`@suman-jangili/privacy‑first‑server`).

---

### Table of Contents

- [Installation](#installation)
- [Development](#development)
- [Build & Preview](#build--preview)
- [Scripts Overview](#scripts-overview)
- [Testing Types](#testing-types)
- [Contributing](#contributing)
- [License](#license)
- [Related Projects](#related-projects)

---

### Installation
From npm:
```bash
npm install @suman-jangili/privacy-first-client
```
**OR** add it as a dependency in your own project
```bash
npm i @suman-jangili/privacy-first-client
```
If you want to run the demo locally, clone the repo and install dev dependencies:
```bash
git clone https://github.com/sumanjangili/privacy-first.git
cd privacy-first/client
npm ci        # installs exact versions from lockfile
```

---

### Development
Start a hot‑reloading dev server:
```bash
npm run dev
```
Open http://localhost:5173 (or the port Vite reports) in your browser.
Changes to any src/**/*.tsx or src/**/*.ts file trigger an automatic reload.

---

### Build & Preview
1. Create a production‑ready bundle:
   ```bash
    npm run build
   ```
2. The compiled assets land in dist/. To preview the built output locally:
   ```bash
   npm run preview
   ```
---

### Scripts Overview
- **dev**	Starts Vite in development mode with hot‑module replacement.
- **build**	Bundles the app for production (vite build).
- **preview**	Serves the dist/ folder locally (vite preview).
- **lint** Runs ESLint on all source files.
- **format** Formats code with Prettier.
- **typecheck** Executes tsc --noEmit to verify TypeScript types without emitting files.

---

### Testing Types
The project ships type declarations out of the box (via the compiled .d.ts files).
To verify they work in a consuming project:
```bash
import { encrypt, decrypt } from '@suman-jangili/privacy-first-client';
// Example usage (pseudo‑code)
const ciphertext = await encrypt('hello world');
const plaintext = await decrypt(ciphertext);
```
If you encounter any type errors, feel free to open an issue.

---

### Contributing
Contributions are welcome!
1. Fork the repository.
2. Create a feature branch:
   ```bash
   git checkout -b feat/my‑feature
   ```
3. Make your changes and run:
   ```bash
   npm run lint && npm run typecheck.
   ```
4. Submit a Pull Request against the main branch.
Please adhere to the existing coding style (ESLint + Prettier) and include tests or type‑checking where applicable.

---

### License
MIT © Suman Jangili. See the LICENSE file for details.

---

### Related Projects
- [Server](https://www.npmjs.com/package/@suman-jangili/privacy-first-server) – a tiny Express API that handles key generation and encryption.
- [See Full Demo Repo](https://github.com/sumanjangili/privacy-first)
npm package: @suman-jangili/real_time_issue_board_ui
Description: Hosts a React + Vite frontend with a live Issue Board for Remote Teams.
Author: Suman Jangili
Latest version: 0.1.0

## Real‑Time Issue Board for small Distributed Teams - Frontend
**Track bugs, feature requests, and stand‑up items instantly.**
> "
> A lightweight, performant, and self‑hosted issue board that lets remote teams - track bugs, feature requests, and daily stand‑up items instantly with real‑time updates, flexible workflows, and full privacy & data ownership —no Jira, Trello, or Azure Boards required.
> Built with a Rust backend (high‑performance REST API + WebSocket sync) for instant board updates and a React frontend (responsive UI, drag‑and‑drop columns). The whole stack can be deployed with a single Docker‑Compose file, making it easy for any team to spin up on a VPS, a home server, or even a Raspberry Pi.
> "

---

### Table of Contents
1. [Why this project](#why-this-project)
2. [Features (MVP)](#features-mvp)
3. [Quick start](#Quick-start)
4. [License](#license)
   
---

### Why this project
- **Fast, real‑time collaboration** – WebSocket‑driven updates mean every teammate sees changes the moment they happen.
- **Self‑hosted & portable** – Deploy with a single docker‑compose.yml to any VPS, home server, or Raspberry Pi.
- **Customizable workflows** – Simple drag‑and‑drop columns, plus hooks for automation tailored to startups and hobby groups.
- **Zero overhead** – Minimal UI, no licensing fees, and no “status‑check” email chains.

---

### Features (MVP)
- Live board sync via WebSockets
- Drag‑and‑drop Kanban columns (React fork DND)
- Rich card data (markdown, assignee, labels, due date, attachments)
- OAuth2 login (GitHub) with role‑based permissions
- Activity log & optional webhook/email notifications
- One‑click Docker‑Compose deployment (Rust API, PostgreSQL, Nginx‑served React UI)

---

### Quick start
```bash
git clone https://github.com/sumanjangili/real-time-issue-board.git
cd real-time-issue-board
docker compose up -d   # builds & starts db, backend, frontend

# Backend API: http://localhost:8000/api
# Frontend UI : http://localhost:3000
```
#### Frontend Development
```bash
cd frontend
npm run dev          # Vite dev server on http://localhost:5173
```
#### Run the frontend stack locally on docker
```bash
docker compose build --no-cache frontend
docker compose up -d frontend    # Test the container
```
```bash
docker compose down   # Stop everything
```

---

### License
The frontend is also released under the **MIT License** (see the repository‑wide LICENSE file).

#### Contributing
- Feel free to open pull requests, report bugs, or suggest enhancements via the GitHub Issues page.
- For larger feature work, consider creating a feature branch and linking the PR to the corresponding issue.

---
npm package: @suman-malik-repo/snapcache
Description: Express middleware for SHA256 ETag hashing, 304 responses, and cache acceleration
Author: Suman Malik
Latest version: 1.0.3

# @suman-malik-repo/snapcache

Express middleware for SHA256 ETag hashing and cache acceleration. Pairs with the [SnapCache CDN script](https://snapcache.ogensync.com) for instant client-side caching.

## Install

```bash
npm install @suman-malik-repo/snapcache
```

## Usage

### Global Middleware

```js
const express = require('express');
const snapCache = require('@suman-malik-repo/snapcache');

const app = express();

// Auto ETag for all GET responses
app.use(snapCache({
  exclude: ['/auth', '/admin'],
  cacheControl: 'private, no-cache'
}));

app.get('/api/users', (req, res) => {
  res.json({ users: [...] }); // ETag auto-added
});
```

### Per-Route Helpers

```js
app.get('/api/user/:id', async (req, res) => {
  const user = await db.getUser(req.params.id);
  res.snapCache(user);     // or res.sendWithETag(user)
});
```

## Options

| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `exclude` | `string[]` | `[]` | Routes to skip |
| `cacheControl` | `string` | `'private, no-cache'` | Cache-Control header |
| `weak` | `boolean` | `false` | Use weak ETags |

## How It Works

1. Server computes `SHA256(JSON.stringify(data))` → ETag
2. Client sends `If-None-Match: "etag"` on repeat requests  
3. If match → `304 Not Modified` (no body sent)
4. If different → `200` with new data + new ETag

## Client SDK

Add the CDN script to your frontend for IndexedDB caching + SWR:

```html
<script src="https://snapcache.ogensync.com/sdk.js"></script>
```

## License

MIT
npm package: @suman-malik-repo/utils
Description: Utility functions for RepoDB
Author: Suman Malik
Latest version: 1.0.3

# @suman-malik-repo/utils

Utility functions for RepoDB and related projects.

## Installation

```bash
npm install @suman-malik-repo/utils
```

## Usage

```javascript
import * as utils from '@suman-malik-repo/utils';
```
npm package: @sumanion/queue
Description: Fast, unopinionated, minimalist queue manager for Node.js
Author: Ion Suman
Latest version: 1.2.0


# Queue Manager

Fast, unopinionated, minimalist queue manager for Node.js

## Installation

Using npm:

```bash
$ npm install @sumanion/queue --save
```

Using yarn:

```bash
$ yarn add @sumanion/queue
```

## Usage

```javascript
// Load the module.
const queue = require('@sumanion/queue')

// Create a queue manager with default options.
const q = queue.create()

// Or set custom options.
const q = queue.create({
  // Maximum number of concurrent active tasks.
  max: 1, // Accepted values: 1..Infinity
  // Queue manager will automatically start to run tasks.
  start: true // Accepted values: true or false
})

// Set the maximum number of concurrent active tasks.
q.max(1)

// Start the queue manager.
q.start()

// Stop the queue manager.
q.stop()

// Return the number of tasks in the queue.
q.size()

// Show the number of active tasks.
q.active()

// Remove all queued tasks.
q.clear()

// Add a new task to the queue.
q(next => {
  // The task contents.
  console.log(1)

  // IMPORTANT: When the task finishes it's job you should
  // always call the `next()` method to start the next task.
  next()
})

// Add another task to the queue.
q(next => {
  // The task contents.
  console.log(2)

  // NOTE: You can wait as long as you need before you call
  // the `next()` method.
  setTimeout(() => {
    // IMPORTANT: When the task finishes it's job you should
    // always call the `next()` method to start the next task.
    next()
  }, 1000)
})

// The queue manager will output:
// 1
// 2
```

## Task Priorities

- `High Priority Tasks` - are executed before all other tasks. If there are many high priority tasks they are executed in the order they were added to the queue manager.

```js
q.high(next => {
  next()
})
```

- `Normal Priority Task` - are executed after all high priority tasks. If there are many normal priority tasks they are executed in the order they were added to the queue manager.

```js
q(next => {
  next()
})
```

- `Low Priority Tasks` - are executed after all high priority and normal priority tasks. If there are many low priority tasks they are executed in the order they were added to the queue manager.

```js
q.low(next => {
  next()
})
```

## Important Notes

- Queue manager will always keep the tasks in the order you added them.
- You should always call the `next()` method manually when your tasks finish to do their jobs.

## Possible Issues

- `next()` method inside a task **must be called exactly one time**, because it decreases the number of currently active tasks by one and if you call it multiple times it will run the wrong number of concurrent tasks. Of course it will back to normal shortly, but you should be aware of this side effect.
- If you will not call the `next()` method on a task when it finishes it's job, queue manager will not start another tasks, it will wait forever the previous task to finish.

## License

MIT
npm package: @sumanreddy/url-fetcher
Description: A simple URL fetcher library
Author: SumanReddy
Latest version: 1.0.5

# @sumanreddy/url-fetcher

A powerful URL fetcher and crawler library that discovers and extracts valid URLs from the web.

## Installation

```bash
npm install @sumanreddy/url-fetcher
```

## Usage

```javascript
import { fetchUrls } from "@sumanreddy/url-fetcher";

// Fetch 10 URLs
const urls = await fetchUrls(10);
console.log(urls);

// Fetch default number of URLs
const moreUrls = await fetchUrls();
console.log(moreUrls);
```

## CLI Usage

```bash
node src/index.js 5  # Fetch 5 URLs
```

## Features

- Configurable URL count
- Smart crawling with retry mechanism
- Domain diversity control
- Bot detection avoidance
- Respects robots.txt and site policies
npm package: @sumanta23/server-wrapper
Description: api server wrapping express with best practices"
Author: sumanta23
Latest version: 2.0.15

# API server

    var config = require("config-wrapper");
    var redisconnection = require("redisconnection-wrapper")(config.get("redis"));

    var mq = require("rabbitmqconnection-wrapper");
    mq.start(config.get("rabbitmq"));

    var logger = require("applogger-wrapper");
    logger.init(config.get("logger"));

    var dbMgr = require('mongodbconnection-wrapper');
    var dbname = process.env.NODE_ENV === 'test' ? "test" : undefined;
    var modelPath= "./db/models";
    var schemaPath= "./db/schemas";

    var boot = require("boot-wrapper");
    var api = require("@sumanta/server-wrapper").api;
    var cors = require("cors");
    var express = require("express");
    var app = express();
    app.use(cors("*"));

    restPath = __dirname+"/rest";
    schemaPath= __dirname+"/schema";
    validationRequired= apidocRequired= basicSecRequired = true;
    xssIgnoreList=[]
    baseURL = "localhost:5000"


    boot.init(config)
    .then(async ()=>{
        await boot.bootlogger(logger);
        await boot.bootredis(redisconnection)
        await dbMgr.initialize(config.get("db"), { dbname, modelPath, schemaPath })
            .then((mInst)=>boot.bootdb(mInst, dbMgr.getModel()));
        await boot.bootrabbitmq(mq.getConn);
    }).then(async ()=>{
        // var Model = appGlobals.dbModels;
        // var vModelName = 'votings';
        // var vDbModels = Model.getModelInstance(vModelName);
        // mq.sendToQueue("test",{"helo":"data"});
        // mq.registerConsumer("test",(data)=>{logger.info(data); return Promise.resolve();});  
        // await vDbModels.create({callId:"55", option:"kl", userId:"ioio"}).tap(()=>vDbModels.findOne({}).tap(console.log))
        api.init(app, 5000, { restPath, schemaPath, validationRequired, apidocRequired, basicSecRequired, xssIgnoreList, baseURL })
        api.loadapi(app);
        api.start(app);
    })

# Socket server
    var _         = require("lodash");
    var debug     = require("debug")("wsserver");
    var boot = require("boot-wrapper");
    var config = require("config-wrapper");
    var redisconnection = require("redisconnection-wrapper")(config.get("redis"));
    var subchannel = require("redisconnection-wrapper")(config.get("redis"));

    var wsconfig = config.get("ws");

    var express = require("express");
    var http = require("http");
    var app = express();
    var server = http.createServer(app);

    var port = process.env.PORT || wsconfig.port;

    boot.init(config)
    .then(async () => {
        await boot.bootredis(redisconnection);
        var senderM = require("@sumanta23/server-wrapper").sender;
        await boot.bootsender(senderM);
        //await boot.enableHealthMonitoring("ws");
    }).then(async () => {
        var ws = require("@sumanta23/server-wrapper").wsserver;
        ws.listen(server, wsconfig, ()=>{}, redisconnection, subchannel, ()=>{});
        server.listen(port, function () {
        debug("server started on localhost:" + port);
        });
    })