open-index/open-npm huggingface dataset:
npm package: @sparkwave/somatic
Description: Functional, Asynchronous, Component-based UI Library that works with JSX
Author: James A. Prempeh
Latest version: 2.6.2

# somatic.js
Functional, Asynchronous, Component-based UI Library that works with JSX

## Install
npm install --save @sparkwave/somatic

## Features
### Function-based
All components in Somatic are regular (stateless) or generator (stateful) synchronous or asynchronous functions, . No classes, hooks, proxies or template languages are needed. These feature allows for simple and direct state management right inside components. 

### Declarative
Somatic supports the JSX syntax popularized by React, allowing you to write HTML-like code directly in JavaScript.

### Props/State interaction management
Somatic allows component authors to manage the interaction between state and props directly in components, without any ugly life-cycle methods as in React, by injecting any props updates in the generators returned from stateful components.

### Strong JSX typing 
Somatic supports very strong JSX typing. Elements and children are well typed, and components can specify if they accept children, something not possible in react

### Key system
Every component is uniquely identified internally by a key. This key is comprised of the component xpath ("Layout-(3)div-(0)-span"), and the component's name. If a component is stateful (generator-based), changing its key (by updating its "key" attribute) will trigger a full re-initialization instead of an additional yield. That allows the refreshing of data defined outside of the "while" loop.
npm package: @sparkwave/standard
Description: Standard library for JavaScript/TypeScript
Latest version: 2.34.2

# standard.js
A standard library for JavaScript/TypeScript

## Features
- Lazy iterable combinators such as _map_, _filter_, _reduce_, etc.
- Lazy async iterable combinators such as _mapAsync_, _filterAsync_, etc.
- Fluent iterable containers: _Sequence_, _Set_, _Array_, _ArrayNumeric_, _Dictionary_
- Functional combinators such as _flip_, _curry_, etc.
- Async combinators such as _promisify_, _sleep_, etc.
- Statistical functions such as _mean_, _median_, _quartiles_, _variance/standard deviation_, etc.
- Advanced _string_, _date-time_, and _numeric_ functions
- Utility _types_, _type guards_, and _value helpers_


## Install
`npm install --save @sparkwave/standard`


## Usage
```ts
// import specific functions from specific modules
import { mapAsync, ZipAsync, isAsyncIterable /*, ...*/ } from "@sparkwave/standard/collections/combinators"
import { keys, entries, pick, omit  /*, ...*/ } from "@sparkwave/standard/object"
import { sleep, promisify } from "@sparkwave/standard/async"

// import everything from a module
import * as containers from "@sparkwave/standard/collections/containers"
const numArray = new containers.Array([1, 2, 3])

// import everything from package
import * as stdlib from "@sparkwave/standard"
type Predicate<T> = stdlib.Predicate<T>
```
npm package: @sparkx/core
Description: Sparkx state management module
Author: Pushkar Anand
Latest version: 0.0.5

core
====
**Sparkx state management module**. This module abstracts out state management part
of the application. It is a facade over immutable js and redux to provide a flux
architecture with an immutable state. It exposes `createStore` and `compose` from
redux library to initialize store and add middlewares (if required).

The `@sparkx/core/lib/stateManagement` module exposes various methods to fire actions
that updates the global and local scope of the application. The reducers are combined
and exposed from `@sparkx/core/lib/model`. All these are supposed to be abstracted out
from the application developer by individual view facade module like `@sparkx/react`
(for react).

It also exposes abstract implementation for controllers and services as `ControllerBase`
and `ServiceBase` respectively. These are the only two entities application developer
needs to know about.

## Usage
```typescript
import { compose, createStore } from '@sparkx/core';
import model from '@sparkx/core/lib/model';

// Creating store.
const store = createStore(
    model,
    compose.apply(this, middlewares),
);
```
npm package: @sparkx/react
Description: Sparkx facade for React
Author: Pushkar Anand
Latest version: 0.0.5

React
=====

**Sparkx facade for React**. This helps in abstracting out state management
methods of `@sparkx/core` and routing methods of `@uirouter`. It exposes `initApp`
and `createRoute` methods along with `RoutingService` class.

It helps in defining the structure of the application and have well defined sepration
of concerns between various part of application.

## Usage

```typescript
import { initApp, createRoute, hashLocationPlugin, RoutingService } from '@sparkx/react';
import * as ReactDOM from 'react-dom';

const routingService = new RoutingService();

ReactDOM.render(
    initApp(
        () => {
            // Register plugin
            routingService.registerPlugin(hashLocationPlugin);

            // Register routes.
            routingService.registerRoutes([
                createRoute({
                    component: () => <div>Hello World</div>,
                    name: 'welcome',
                    url: '/welcome',
                }),
                createRoute({
                    component: () => <div>404 Page not Found!</div>,
                    name: '404',
                    url: '/notFound',
                })
            ]);

            // Setting starting route.
            routingService.setInitialState('welcome');

            // Setting fallback route.
            routingService.set404State('404');
        }
    ),
    document.getElementById('root')
);
```
npm package: @sparkx/services
Description: Sparkx services
Author: Pushkar Anand
Latest version: 0.0.5

Services
========

**Sparkx services module**. A module to contain various services to help in
application development. Each service is meant to be independent of each other
but can also be used together.

## Usage

```typescript
import { HTTPService } from '@sparkx/services';

const httpService = new HTTPService();
httpService.get('/my/api/endpoint').then(resp => console.log(resp.data));
```
npm package: @sparky002/validator-lite
Description: A tiny, dependency-free JavaScript validation library for email, phone, URL, password, PAN, PIN, IP, UUID, and more.
Author: Sparky
Latest version: 1.0.0

# @sparky/validator-lite

A lightweight, zero-dependency JavaScript validation library for modern web and Node.js applications.  
Quickly validate emails, URLs, phone numbers, passwords, PAN, PIN codes, UUIDs, IP addresses, and more — all in one tiny utility.

---

## 🚀 Features

- 📧 `isEmail` — Basic email format validation
- 📱 `isPhone` — International phone number format
- 🌐 `isURL` — Validates HTTP/HTTPS/FTP URLs
- 🔒 `isStrongPassword` — Checks for uppercase, lowercase, digit, symbol, min length
- 📭 `isEmpty` — Checks if value is empty (string, object, array, null, etc.)
- 🔢 `isNumeric` — Validates integer/float strings
- 🔤 `isAlpha` / `isAlphanumeric` — Character-only or char+num strings
- 📏 `isLength` — Validates string length with min/max
- 📅 `isDate` — Checks if value is a valid date
- ✅ `isBoolean` — Accepts true/false, 0/1, "true"/"false"
- 🧾 `isJSON` — Checks for valid JSON strings
- 🧬 `isUUID` — Validates UUID v4
- 🎨 `isHexColor` — Hex color codes (#fff / #ffffff)
- 🧠 `isIP` — IPv4 and IPv6 address check
- 💳 `isCreditCard` — Basic pattern match for Visa, MasterCard, Amex, Discover
- 🇮🇳 `isIndianPIN` — Indian postal code (6-digit)
- 🇮🇳 `isPAN` — Indian PAN card format (e.g., `ABCDE1234F`)

---

## 📦 Installation

```bash
npm install @sparky002/validator-lite