open-index/open-npm huggingface dataset:
npm package: @parallel-park/run-jobs
Description: Parallel async work with an optional concurrency limit, like Bluebird's Promise.map
Author: Lily Skye
Latest version: 0.3.1

# @parallel-park/run-jobs

Parallel async work with an optional concurrency limit, like [Bluebird's Promise.map](http://bluebirdjs.com/docs/api/promise.map.html).

## Usage

`@parallel-park/run-jobs` exports one function: `runJobs`.

### `runJobs`

`runJobs` is kinda like `Promise.all`, but instead of running everything at once, it'll only run a few Promises at a time (you can choose how many to run at once). It's inspired by [Bluebird's Promise.map function](http://bluebirdjs.com/docs/api/promise.map.html).

To use it, you pass in an iterable (array, set, generator function, etc) of inputs and a mapper function that transforms each input into a Promise. You can also optionally specify the maximum number of Promises to wait on at a time by passing an object with a `concurrency` property, which is a number. The concurrency defaults to 8.

When using an iterable, if the iterable yields a Promise (ie. `iterable.next() returns { done: false, value: Promise }`), then the yielded Promise will be awaited before being passed into your mapper function. Additionally, async iterables are supported; if `iterable.next()` returns a Promise, it will be awaited.

```ts
import { runJobs } from "parallel-park";

const inputs = ["alice", "bob", "carl", "dorsey", "edith"];
const results = await runJobs(
  inputs,
  async (name, index, inputsCount) => {
    // Do whatever async work you want inside this mapper function.
    // In this case, we use a hypothetical "getUser" function to
    // retrieve data about a user from some web API.
    console.log(`Getting fullName for ${name}...`);
    const user = await getUser(name);
    return user.fullName;
  },
  // This options object with concurrency is an optional argument.
  // If unspecified, it defaults to { concurrency: 8 }
  {
    // This number specifies how many times to call the mapper
    // function before waiting for one of the returned Promises
    // to resolve. Ie. "How many promises to have in-flight concurrently"
    concurrency: 2,
  }
);
// Logs these two immediately:
//
// Getting fullName for alice...
// Getting fullName for bob...
//
// But, it doesn't log anything else yet, because we told it to only run two things at a time.
// Then, after one of those Promises has finished, it logs:
//
// Getting fullName for carl...
//
// And so forth, until all of them are done.

// `results` is an Array of the resolved value you returned from your mapper function.
// The indices in the array correspond to the indices of your inputs.
console.log(results);
// Logs:
// [
//   "Alice Smith",
//   "Bob Eriksson",
//   "Carl Martinez",
//   "Dorsey Toth",
//   "Edith Skalla"
// ]
```

## License

MIT
npm package: @parallel-web/opencode-plugin
Description: OpenCode plugin that replaces webfetch and websearch with Parallel CLI
Author: Parallel Web
Latest version: 1.0.1

# @parallel-web/opencode-plugin

OpenCode plugin that adds `parallel-search` and `parallel-fetch` tools powered by [Parallel Web](https://parallel.ai) through `parallel-cli`.

**Why use Parallel tools?**

- More accurate and relevant search results
- Intelligent content extraction that understands page structure
- Extended excerpts optimized for LLM context windows
- Faster and more reliable than built-in alternatives

## Installation
### 1. Add the plugin to your OpenCode config

```json
{
  "$schema": "https://opencode.ai/config.json",
  "plugin": ["@parallel-web/opencode-plugin"]
}
```

### 2. Authenticate

**Option A: Parallel CLI login (recommended)**

1. Run `opencode auth login`
2. Select **"Parallel"** → **"Login with Parallel CLI"** OR **Input API key from platform.parallel.ai**
3. Complete authorization in your browser/device flow


**Option B: Environment variable**

```bash
export PARALLEL_API_KEY=your_api_key
```

Get your API key at [platform.parallel.ai](https://platform.parallel.ai).

The plugin invokes `parallel-cli` under the hood for both tools.

## Tools

| Tool              | Description                                         |
| ----------------- | --------------------------------------------------- |
| `parallel-search` | Web search with high-quality, LLM-optimized results |
| `parallel-fetch`  | Intelligent content extraction from any URL         |

### Example parallel-search

```
Search for the latest developments in AI safety research
```

### Example parallel-fetch

```
Fetch https://docs.parallel.ai/api-reference
```

## License

MIT
npm package: @parallelworks/client
Description: Official TypeScript client for Parallel Works ACTIVATE API
Author: Parallel Works
Latest version: 7.34.0

# @parallelworks/client

Official TypeScript client for the Parallel Works ACTIVATE platform API.

## Installation

```bash
npm install @parallelworks/client
```

For SWR hooks support (React):

```bash
npm install @parallelworks/client swr swr-openapi
```

## Quick Start

The simplest way to create a client - just pass your credential:

```typescript
import { Client } from '@parallelworks/client'

// The platform host is automatically extracted from your credential
const client = Client.fromCredential(process.env.PW_API_KEY!)

const { data, error } = await client.GET('/api/buckets')
```

See the [examples](./examples) directory for complete runnable examples.

## Authentication

### Automatic Host Detection

API keys (`pwt_...`) and JWT tokens contain the platform host encoded within them. Use `fromCredential` to automatically extract it:

```typescript
// API key - host decoded from first segment after pwt_
const client = Client.fromCredential('pwt_Y2xvdWQucGFyYWxsZWwud29ya3M.xxxxx')
// Connects to: https://cloud.parallel.works

// JWT token - host read from platform_host claim
const client = Client.fromCredential('eyJhbGci...')
// Connects to the host in the token's platform_host claim
```

### Explicit Host

If you prefer to specify the host explicitly:

```typescript
// API Key (Basic Auth) - best for long-running integrations
const client = new Client('https://cloud.parallel.works')
  .withApiKey('pwt_...')

// JWT Token (Bearer) - best for scripts, expires in 24h
const client = new Client('https://cloud.parallel.works')
  .withToken('eyJhbGci...')

// Auto-detect credential type
const client = new Client('https://cloud.parallel.works')
  .withCredential(process.env.PW_CREDENTIAL!)
```

### Credential Helpers

```typescript
import { isApiKey, isToken, extractPlatformHost } from '@parallelworks/client'

isApiKey('pwt_abc.xyz')           // true
isToken('eyJ.abc.def')            // true
extractPlatformHost('pwt_...')    // "cloud.parallel.works"
```

## SWR Hooks (React)

```tsx
// lib/api.ts
import { Client } from '@parallelworks/client'
import { createSwrHooks } from '@parallelworks/client/swr'

// Credential should be securely provided by your server (e.g., via session)
const client = Client.fromCredential(credential)

export const { useQuery, useImmutable, useInfinite } = createSwrHooks(client)
```

```tsx
// components/BucketList.tsx
import { useQuery } from '@/lib/api'

export function BucketList() {
  const { data, error, isLoading } = useQuery('/api/buckets')

  if (isLoading) return <div>Loading...</div>
  if (error) return <div>Error: {error.message}</div>

  return (
    <ul>
      {data?.map(bucket => (
        <li key={bucket.id}>{bucket.name}</li>
      ))}
    </ul>
  )
}
```

## Documentation

For full API documentation, visit [https://parallelworks.com/docs](https://parallelworks.com/docs).

## License

MIT
npm package: @paralogic/frappe-datatable
Description: A modern datatable library for the web
Author: Faris Ansari
Latest version: 1.17.6

<div align="center">
    <img src="https://github.com/frappe/design/raw/master/logos/logo-2019/frappe-datatable-logo.png" height="128">
    <h2>Frappe DataTable</h2>
    <p align="center">
    <p>
    A modern datatable library for the web
    </p>

[![Test and Release](https://github.com/frappe/datatable/workflows/Test%20and%20Release/badge.svg)](https://github.com/frappe/datatable/actions?query=workflow%3A%22Test+and+Release%22)
[![npm version](https://badge.fury.io/js/frappe-datatable.svg)](https://badge.fury.io/js/frappe-datatable)
[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT)
![npm bundle size (minified + gzip)](https://img.shields.io/bundlephobia/minzip/frappe-datatable.svg)
[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)


</div>

## Introduction

Frappe DataTable is a simple, modern and interactive datatable library for displaying tabular data. Originally built for [ERPNext](https://github.com/frappe/erpnext), it can be used to render large amount of rows without sacrificing performance and has the basic data grid features like inline editing and keyboard navigation. It does not require jQuery, unlike most data grids out there.

## Demo

![datatable-demo-2](https://user-images.githubusercontent.com/9355208/40740030-5412aa40-6465-11e8-8542-b0247ab1daac.gif)

## Features

### Cell Features

* Custom Formatters
* Inline Editing
* Mouse Selection
* Copy Cells
* Keyboard Navigation
* Custom Cell Editor

### Column Features

* Reorder Columns
* Sort by Column
* Remove / Hide Column
* Custom Actions
* Resize Column
* Flexible Layout

### Row Features

* Row Selection
* Tree Structured Rows
* Inline Filters
* Large Number of Rows
* Dynamic Row Height

## Install

```bash
yarn add frappe-datatable
# or
npm install frappe-datatable
```

> Note: [`sortablejs`](https://github.com/RubaXa/Sortable) is required to be installed as well.

## Usage

```js
const datatable = new DataTable('#datatable', {
  columns: [ 'First Name', 'Last Name', 'Position' ],
  data: [
    [ 'Don', 'Joe', 'Designer' ],
    [ 'Mary', 'Jane', 'Software Developer' ]
  ]
});
```

## Contribution

* `yarn start` - Start dev server
* Open `index.html` located in the root folder, and start development.
* Run `yarn lint` before committing changes
* This project uses [commitizen](https://github.com/commitizen/cz-cli) for conventional commit messages, use `yarn commit` command instead of `git commit`

## Read the blog

[Making a new datatable for the web](https://medium.com/frapp%C3%A9-thoughts/things-i-learned-building-a-library-for-the-web-6846a588bf53)


## License

[MIT](http://opensource.org/licenses/MIT)
npm package: @param_tpss/react-dev-notes
Description: A sticky developer note panel with drag-and-drop tasks and markdown editing, for React apps (dev-only tool).
Author: Paramjeet Singh
Latest version: 1.0.13

# react-dev-notes

> 🛠️ A developer-only sticky notes panel with live Markdown editing, drag-and-drop task management, and persistent storage — built for React apps.

---

## ✨ Features

- ✅ Sticky notes panel always on screen (dev-only)
- ✅ Live Markdown editing for quick dev notes
- ✅ Drag-and-drop task management with priorities
- ✅ Persistent storage via `localStorage`
- ✅ Toggle show/hide with a floating button
- ✅ Only visible in development mode

---

## 📦 Installation

```bash
npm install react-dev-notes
OR
yarn add react-dev-notes

---

🚀 Usage
import React from "react";
import DevNotesPanel from "react-dev-notes";
import "@param_tpss/react-dev-notes/style";

function App() {
  return (
    <>
      <DevNotesPanel />
      <div className="p-4">
        <h1 className="text-2xl font-bold">Your App Content</h1>
      </div>
    </>
  );
}

export default App;

 The panel only shows in development mode (process.env.NODE_ENV !== 'production').
```
npm package: @param_tpss/react-loaders
Description: High-performance React loaders and skeleton components.
Author: Paramjeet Singh
Latest version: 1.0.8

# @param_tpss/react-loaders

High-performance React loaders and skeleton components with Tailwind CSS support.

## 📦 Installation

```bash
npm install @param_tpss/react-loaders
# or
yarn add @param_tpss/react-loaders

```

🎨 Styles (Required)
You must import the package CSS for proper styling:
import "@param_tpss/react-loaders/style";

🚀 Usage
import React from "react";
import { Loader } from "@param_tpss/react-loaders";
import "@param_tpss/react-loaders/style";

const App = () => (

  <div className="flex justify-center items-center h-screen">
    <Loader type="ios-spinner" size="lg" className="text-blue-500" />
  </div>
);

✨ Props
Prop Type Default Description
type string "dots" Loader type (dots, ios-spinner, etc.)
size string "md" Loader size (xs, sm, md, lg, xl, 2xl)
className string "" Tailwind utility classes (for color, margin, etc.)

📚 Examples
<Loader type="dots" size="sm" className="text-red-500" />
<Loader type="ios-spinner" size="xl" className="text-green-600" />

---

## 📄 License

This project is licensed under the [MIT License](./LICENSE).

You are free to use, modify, and distribute this software with proper attribution.

&copy; 2025 Paramjeet Singh