open-index/open-npm huggingface dataset:
npm package: @larsgw/formica
Description: SDK and tools for data from the Library of Identification Resources
Author: Lars Willighagen
Latest version: 0.9.0

# Formica

**Formica** is an SDK and a collection of tools for the data in the Library of
Identification Resources.

## Install

Install globally:

    npm install --global @larsgw/formica

Run locally:

    npx --package @larsgw/formica -- ...

## CLI

  - `loir-validate-catalog [./catalog.csv ./authors.csv ./places.csv ./publishers.csv]`:
    Validate the CSV files containing metadata ([schema](https://github.com/identification-resources/catalog/blob/main/docs/tools-resources.md)).
  - `loir-validate-resources [./B1234.txt]`:
    Validate the `.txt` files containing information on the taxonomic scope of keys
    ([documentation](https://github.com/identification-resources/catalog/blob/main/docs/resources-txt.md)).
  - `loir-resources-process [./resources]`:
    Interactive tool to convert the aforementioned `.txt` files to Darwin Core archives
    ([documentation](https://github.com/identification-resources/catalog/blob/main/docs/resources-dwc.md)),
    and link the taxa to GBIF and Catalogue of Life identifiers. Use the `-u` or
    `--update` flag in a Git repo to update existing Darwin Core files while keeping
    the identifiers stable (in most cases).
  - `loir-resources-index [./resources]`: Create indices of the Darwin Core archives.

## API

```js
const Formica = require('@larsgw/formica')

// Load catalog data
const catalog = Formica.catalog.loadData(`...`, 'catalog')
```
npm package: @larsj02/cf
Description: Simple TypeScript wrapper for the CurseForge API
Latest version: 0.1.0

# CF-API-Wrapper (@larsj02/cf)

Simple, typed TypeScript wrapper around the CurseForge API.

Works with Node 18+ (built-in fetch). Provides enums and request/response types for a smooth dev experience.

## Installation

```bash
npm install @larsj02/cf
```

You’ll need a CurseForge API key. Set it via environment variable:

```bash
export CF_API_KEY=your-key
```

Or copy the example env file and fill it in:

```bash
cp .env.example .env
```

## Quick start

```ts
import { CurseForgeClient, ModsSearchSortField, ModLoaderType } from '@larsj02/cf';

const cf = new CurseForgeClient({ apiKey: process.env.CF_API_KEY! });

const res = await cf.mods.search({
	gameId: 1, // World of Warcraft
	searchFilter: 'bag',
	sortField: ModsSearchSortField.Popularity,
		sortOrder: 'desc',
	modLoaderType: ModLoaderType.Any,
});

console.log(res.data.map(m => m.name));
```

## Examples

Build once, then run any example (they auto-load dotenv):

```bash
npm run build

# Mods
npm run example:search
npm run example:mods:featured

# Files
npm run example:files:download

# Categories / Versions
npm run example:categories
npm run example:versions

# Minecraft
npm run example:minecraft

# Fingerprints
npm run example:fingerprints
```

## API surface

- Mods
	- search(params)
	- get(modId)
	- files(modId, pageSize?, index?)
	- description(modId)
	- getMany(ids)
	- featured(request)
- Files
	- get(modId, fileId)
	- getMany(fileIds)
	- changelog(modId, fileId)
	- downloadUrl(modId, fileId)
- Games
	- list()
	- get(id)
- Categories
	- list(gameId, classId?)
- Versions
	- getGameVersions(gameId)
	- getGameVersionTypes(gameId)
- Fingerprints
	- match({ fingerprints })
- Minecraft
	- versionLatest()
	- version(versionString)
	- modloaders()
	- modloader(name)

## Enums included

- FileRelationType
- FileReleaseType
- FileStatus
- HashAlgo
- ModLoaderType
- ModsSearchSortField
- SortOrder ('asc' | 'desc')
- GameVersionTypeStatus
- ModStatus

Use them to strongly type your requests and check responses:

```ts
import { ModsSearchSortField, ModLoaderType, FileReleaseType } from '@larsj02/cf';

await cf.mods.search({
	gameId: 432, // Minecraft
	sortField: ModsSearchSortField.TotalDownloads,
	modLoaderTypes: [ModLoaderType.Forge, ModLoaderType.Fabric],
});

const file = (await cf.files.get(modId, fileId)).data;
if (file.releaseType === FileReleaseType.Release) {
	// stable
}
```

## Node and fetch

- Node 18+ is required (global fetch).
- If you need a custom fetch (e.g., for proxies), pass it in the client options.

```ts
import { fetch as undiciFetch } from 'undici';
const cf = new CurseForgeClient({ apiKey: process.env.CF_API_KEY!, fetch: undiciFetch });
```

## Dev scripts

```bash
npm run typecheck
npm run test
npm run build
```

## Publish (maintainers)

This package is configured to publish ESM with types. To publish:

```bash
npm login
npm publish --access public
```

The prepublishOnly hook will build and run tests.

## License

MIT
npm package: @larskarbo/bonfida-token-vesting
Description: ## Example
Latest version: 0.0.11

# Simple JS bindings

## Example

A linear unlock example can be found in `example.ts`

## Quickstart

Contract address on Devnet

```
DLxB9dSQtA4WJ49hWFhxqiQkD9v6m67Yfk9voxpxrBs4
```

Contract address on Mainnet

```
CChTq6PthWU82YZkbveA3WDf7s97BWhBK4Vx9bmsT743
```

The code allows you to

- Create vesting instructions for any SPL token: `createCreateInstruction`
- Create unlock instructions: `createUnlockInstruction`
- Change the destination of the vested tokens: `createChangeDestinationInstruction`

(To import Solana accounts created with [Sollet](https://sollet.io) you can use `getAccountFromSeed`)

```
Seed 9043936629442508205162695100279588102353854608998701852963634059
Vesting contract account pubkey:  r2p2mLJvyrTzetxxsttQ54CS1m18zMgYqKSRzxP9WpE
contract ID:  90439366294425082051626951002795881023538546089987018529636340fe
✅ Successfully created vesting instructions
🚚 Transaction signature: 2uypTM3QcroR7uk6g9Y4eLdniCHqdQBDq4XyrFM7hCtTbb4rftkEHMM6vJ6tTYpihYubHt55xWD86vHB857bqXXb

Fetching contract  r2p2mLJvyrTzetxxsttQ54CS1m18zMgYqKSRzxP9WpE
✅ Successfully created unlocking instructions
🚚 Transaction signature: 2Vg3W1w8WBdRAWBEwFTn2BtMkKPD3Xor7SRvzC193UnsUnhmneUChPHe7vLF9Lfw9BKxWH5JbbJmnda4XztHMVHz

Fetching contract  r2p2mLJvyrTzetxxsttQ54CS1m18zMgYqKSRzxP9WpE
✅ Successfully changed destination
🚚 Transaction signature: 4tgPgCdM5ubaSKNLKD1WrfAJPZgRajxRSnmcPkHcN1TCeCRmq3cUCYVdCzsYwr63JRf4D2K1UZnt8rwu2pkGxeYe
```
npm package: @larskarbo/next-s3-upload
Description: [![Next S3 Upload](https://next-s3-upload.codingvalue.com/og-image.png)](https://next-s3-upload.codingvalue.com/)
Author: Ryan Toronto
Latest version: 0.2.6

# Next.js S3 Upload

[![Next S3 Upload](https://next-s3-upload.codingvalue.com/og-image.png)](https://next-s3-upload.codingvalue.com/)

The easiest way to upload files from a Next.js app to S3.

## Documentation

Visit the [Next S3 Upload website](https://next-s3-upload.codingvalue.com/) for full documentation, install instructions, and usage examples.
npm package: @larskarbo/tsconfig
Description: Shared TypeScript config for my projects
Latest version: 2.0.2

# tsconfig

> Shared [TypeScript config](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html) for my projects

## Install

```
$ npm install --save-dev @sindresorhus/tsconfig
```

## Usage

`tsconfig.json`

```json
{
	"extends": "@sindresorhus/tsconfig/tsconfig.json",
	"compilerOptions": {
		"outDir": "dist"
	}
}
```

When you are targeting a higher version of Node.js, check the relevant ECMAScript version and add it as `target`:

```json
{
	"extends": "@sindresorhus/tsconfig/tsconfig.json",
	"compilerOptions": {
		"outDir": "dist",
		"target": "ES2021"
	}
}
```
npm package: @larskendall/create-web-app
Description: Scaffold a new web app with devcontainers, SOPS, Claude Code, Loki/Grafana, and more
Author: Lars Kendall
Latest version: 0.1.0

# @larskendall/create-web-app

Scaffold a new web app with devcontainers, SOPS encryption, Claude Code, Loki/Grafana logging, and more.

## Usage

```bash
pnpm create @larskendall/web-app my-project
# or
npx @larskendall/create-web-app my-project
```

The CLI will prompt you to configure:

- PostgreSQL, Loki, and Grafana host ports
- SOPS age encryption key generation
- Git repository initialization
- Beads task tracking initialization
- Dependency installation via pnpm

## What you get

A monorepo with two packages (`common` and `web`) and a full development environment:

- **Devcontainer** — Docker-based dev environment for VS Code
- **PostgreSQL** — database with automatic test DB creation
- **Loki + Grafana** — log aggregation and querying
- **SOPS + age** — encrypted secrets management
- **Claude Code** — AI assistant configuration with custom commands and skills
- **Beads** — local task/issue tracking
- **Moon** — monorepo task orchestration
- **Just** — command runner with project recipes
- **GitHub Actions** — CI workflow
- **Railway** — deployment configuration
- **ESLint** — linting with TypeScript support
- **pnpm workspaces** — package management

## Requirements

- Node.js >= 20
- pnpm

Optional tools (the CLI gracefully skips these if not found):

- [age](https://github.com/FiloSottile/age) — for SOPS key generation
- [bd (beads)](https://github.com/steveyegge/beads) — for task tracking

## License

MIT
npm package: @larskoelpin/maybe.js
Description: Maybe Monad for javascript
Author: Lars Kölpin
Latest version: 0.0.1

# Maybe
Simple Maybe Monad

Check spec for more examples

```
    it('Does not propagate null', () => {
        function getUser() {
            return new Maybe({
                getAvatar: function() {
                    return new Maybe(null); // no avatar
                }
            });
        }
        const url = getUser()
            .chain(user => user.getAvatar())
            .chain(avatar => avatar.url)
        expect(url.isNothing()).toBe(true);
    })
```
npm package: @larspa/task-queue
Description: A simple way to queue asynchronous tasks
Author: Lars Spaenij
Latest version: 1.0.2

# task-queue

> A simple way to queue asynchronous tasks

[![NPM Version][npm-image]][npm-url]

## Install

```bash
npm i -S @larspa/task-queue

yarn add @larspa/task-queue -S
```

## Usage

```js
import TaskQueue from '@larspa/task-queue';

const taskQueue = new TaskQueue();

const task1 = () =>
  new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log("t1 success");
      resolve('test 1');
    }, 100);
  });

const task2 = () =>
  new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log("t2 success");
      resolve('test 2');
    }, 1000);
  });

const task3 = () =>
  new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log("t3 success");
      resolve('test 3');
    }, 500);
  });

taskQueue.enqueue(task1).then(console.log);
taskQueue.enqueue(task2).then(console.log);
taskQueue.enqueue(task3).then(console.log);

// output after 1000ms: t1 success
// output after 1000ms: test 1
// output after 1100ms: t2 success
// output after 1100ms: test 2
// output after 1600ms: t3 success
// output after 1600ms: test 3
```

## License

[MIT](http://vjpr.mit-license.org)

[npm-image]: https://img.shields.io/npm/v/@larspa/task-queue.svg
[npm-url]: https://npmjs.org/package/@larspa/task-queue
npm package: @larsroettig/component-targetables
Description: Simplify creating maintainable PWAStudio Projects
Author: Lars Roettig
Latest version: 3.0.0

# PWAStudio `.targetables.js` Plugins

[![Codacy Badge](https://api.codacy.com/project/badge/Grade/938640a9bab645348a24437daaca3778)](https://app.codacy.com/gh/larsroettig/component-targetables?utm_source=github.com&utm_medium=referral&utm_content=larsroettig/component-targetables&utm_campaign=Badge_Grade_Settings)
[![Coverage Status](https://coveralls.io/repos/github/larsroettig/component-targetables/badge.svg?branch=main)](https://coveralls.io/github/larsroettig/component-targetables?branch=main)

Allows to use `.targetables.js` for PWAStudio

## Usage Exsample

```javascript
const { ExtendLocalIntercept } = require('@larsroettig/component-targetables');

function localIntercept(targets) {
    const { Targetables } = require('@magento/pwa-buildpack');
    const targetables = Targetables.using(targets);

    const extendLocalIntercept = new ExtendLocalIntercept(targetables);
    extendLocalIntercept.allowCustomTargetables();
    extendLocalIntercept.allowCssOverwrites();
}

module.exports = localIntercept;
```

*Big shoutout to Chris Brabender for this blog post*
https://dev.to/chrisbrabender/simplifying-targetables-in-pwa-studio-p8b

## Api Documentation
### allowCssOverwrites

▸ **allowCssOverwrites**(`targetablesSearchPaths?`, `fileExtendsion?`, `magentoPath?`): `void`

#### Parameters

| Name | Type | Default value |
| :------ | :------ | :------ |
| `fileExtendsion` | `string` | `'*.module.css'` |
| `targetablesSearchPaths` | `string[]`| `['src/components', 'src/RootComponents']` |
| `magentoPath` | `string` | `'node_modules/@magento'` |

#### Returns

`void`

___

### allowCustomTargetables

▸ **allowCustomTargetables**(`targetablesSearchPaths?`, `fileExtendsion?`, `magentoPath?`): `void`

Allows to place a custome targetable with given matching filepattern.

#### Parameters

| Name | Type | Default value |
| :------ | :------ | :------ |
| `fileExtendsion` | `string` | `'*.targetables.js'` |
| `targetablesSearchPaths` | `string[]`| `['src/components', 'src/RootComponents']` |
| `magentoPath` | `string` | `'node_modules/@magento'` |

#### Returns

`void`

### Demo
https://github.com/larsroettig/demo-component-targetables
npm package: @larsroettig/create-pwa-extension
Description: Starter for amazing Magento PWA Studio extensions
Author: Lars Roettig
Latest version: 3.1.0

# Starter React PWA Studio extensions

An extension generator for Magento PWA Studio includes all you need to build an amazing extension

- 📏 **ESLint** - JavaScript linter
- 💖 **Prettier** - Opinionated Code Formatter
- 📄 **Jest** - Setup React Testing Library
    - 🦉 **@testing-library/jest-dom** - Custom jest matchers the state of the DOM
    - 🐏 **@testing-library/react-hooks** - React hooks testing utilities that encourage good testing practices
- 🐶 **Husky** - Use git hooks with ease
- ⚡  **Automatically installs project's peer dependencies** - 
- 🗂 **Basic Module structure**

## 🚀 Getting started

```bash
yarn create @larsroettig/pwa-extension
```

```bash
npm init @magento/pwa
```
npm package: @larsroettig/react-cookie-popup
Description: React TypeScript Cookie popup
Author: Lars Roettig
Latest version: 2.0.1

![npm
version](https://badge.fury.io/js/%40larsroettig%2Freact-cookie-popup.svg)
![Travis
Status](https://travis-ci.org/larsroettig/react-cookie-popup.svg?branch=master)
![Coverage
Status](https://coveralls.io/repos/github/larsroettig/react-cookie-popup/badge.svg?branch=master)
![Greenkeeper
badge](https://badges.greenkeeper.io/larsroettig/react-cookie-popup.svg)

Is a small React TypeScript Module allows to render a cookie popup based
on Tailwind CSS.

Example Styling
===============

![react\_modal](https://raw.githubusercontent.com/larsroettig/react-cookie-popup/master/doc/react_modal.png)

**A full Demo can you find here:**
<https://github.com/larsroettig/react-cookie-popup-demo>

Installation
============

    yarn add @larsroettig/react-cookie-popup

or npm

    npm i @larsroettig/react-cookie-popup

Components
----------

<table>
<colgroup>
<col style="width: 50%" />
<col style="width: 50%" />
</colgroup>
<tbody>
<tr class="odd">
<td><p>Component Names</p></td>
<td><p>Function</p></td>
</tr>
<tr class="even">
<td><p>CookiePopup</p></td>
<td><p>The PopUp Element</p></td>
</tr>
<tr class="odd">
<td><p>CookieImprintButton</p></td>
<td><p>Shows a button to revoke the user decision for the imprint deletes all cookie</p></td>
</tr>
<tr class="even">
<td><p>CookieButton</p></td>
<td><p>Simple Tailwind Button Element with a clickCallback</p></td>
</tr>
</tbody>
</table>

**You can import the CookiePopup like this:**

    import {CookiePopup} from "@larsroettig/react-cookie-popup";

**How to use the CookiePopup:**

    <CookiePopup>
        <section>
            <h4 className="py-5 text-xl">
                   A very nice Cookie Message
            </h4>
        </section>
    </CookiePopup>

Contribute
----------

**Installation:**

    git clone git@github.com:larsroettig/react-cookie-popup.git
    yarn install

**Execute Tests:**

    git clone git@github.com:larsroettig/react-cookie-popup.git
    yarn install
    yarn test:watch
npm package: @larssk/api-hook
Description: My personal and preferred API hook for React. Published to NPM to prevent redundancy and version obsolescence across projects.
Author: Lars Kvihaugen
Latest version: 2.4.0

# API hook

### Status

[![Publish package to NPM](https://github.com/LarsSK06/api-hook/actions/workflows/publish.yaml/badge.svg)](https://github.com/LarsSK06/api-hook/actions/workflows/npm-publish.yaml)

### What is this?

This is my own personal and preferred API hook made myself for React. This is mainly made to prevent redundancy and version obsolescence across my own projects.


### Why was this created?

To prevent writing the same code across all my projects, as well as keeping the scripts up to date.

### How to use?

1. Wrap project in the context provider from the package.
2. Create a configuration. This can be done by either satisfying the `Config` interface/type, and applying it as a prop to the provider, or using the `createConfig` function, which returns an object of type `Config`, which you again apply as a prop.
3. Use `useApi` with type parameters to take use of the package/hook.
npm package: @larsthorup/local
Description: Simplify requiring local modules
Author: Lars Thorup
Latest version: 0.6.3

# node-local-require

[![npm version](https://badge.fury.io/js/%40larsthorup%2Flocal.svg)](https://www.npmjs.com/package/@larsthorup/local)
[![Build Status](https://travis-ci.org/larsthorup/node-local-require.png)](https://travis-ci.org/larsthorup/node-local-require)

Simplify requiring local modules

The purpose of this module is to make it easy to keep self-contained Node modules in the same repo as the rest of your app during initial development, in such a way that you can easily convert the module to be a real external module eventually. 


## Usage

    npm install @larsthorup/local --save

    var local = require('@larsthorup/local');
    var config = local('config');


## Verification

You can optionally declare local modules in dependency order in package.json. If so, local() will verify requests against the declaration, unless NODE_ENV is production:

    { 
      "config": {
        "@larsthorup/local": {
          "modules": [
            "core",
            "lib"
          ]
        }
      }
    }

    var util = local('util'); // Note: will throw an error

    var core = local('core'); // Note: will succeed if in some source file in lib
    
    var lib = local('lib'); // Note: will throw an error if in some source file in core
npm package: @larsthorup/react-test-renderer
Description: A custom React renderer for faster testing of React components
Author: Lars Thorup
Latest version: 1.0.0

# @larsthorup/react-test-renderer

A custom React renderer for faster testing of React components

## Install

```sh
npm install @larsthorup/react-test-renderer
```

## Use

Import:

```tsx
import { TestRenderer } from '@larsthorup/react-test-renderer';
```

Render:

```tsx
const renderer = await TestRenderer.create(<App />);
```

Find by text, type or props:

```tsx
// return object if found
expect(renderer.findByType('div')).toBeDefined();

// return undefined if not found
expect(renderer.findByType('blink')).not.toBeDefined();

// find by text
expect(renderer.findByText('Save').type).toBe('button');

// find all
expect(renderer.findAllByProps({ type: 'checkbox' })).toHaveLength(5);
```

Inspect type and props:

```tsx
expect(renderer.findByProps({ placeholder: 'title' }).type).toBe('input');
expect(renderer.findByProps({ placeholder: 'title' }).props.value).toBe('Swim');
```

Trigger event handlers:

```tsx
import { change, click, submit } from "@larsthorup/react-test-renderer";
...
await click(renderer.findByText("Login"));
await change(renderer.findByProps({ placeholder: 'password' }), { target: { value: 'secret' } });
await submit(renderer.findByType('form'), { preventDefault: () => {} });
```

## Publish

```
npm version minor
npm publish
git push
```
npm package: @larswander/png-text
Description: Read and write PNG tEXT chunks
Author: Lars Wander
Latest version: 1.0.0

# PNG-TEXT

A small library for reading and writing arbitrary [PNG tEXt chunks](https://www.w3.org/TR/PNG-Chunks.html).

The PNG specification allows for key/value strings to be attached to an image (the strings must be ASCII, and the key cannot exceed 79 characters).

## Usage

```js

import {writeTextToBlob, readTextFromBlob} from 'png-text';

// Say we want to write these entries to a PNG file.
const metadata = {author: 'me', hash: '123'};

// If you have a canvas object....
canvas.toBlob(blob => {
  const newBlob = await writeTextToBlob(blob, metadata);
  const newMetadata = await readTextFromBlob(newBlob);
  console.log(newMetadata) // author: me, hash: 123
}, 'image/png');

// If you have an image you load remotely...
fetch('my-image.png')
  .then(response => response.blob())
  .then(blob => {
    const newBlob = await writeTextToBlob(blob, metadata);
    const newMetadata = await readTextFromBlob(newBlob);
    console.log(newMetadata) // author: me, hash: 123
  });
```

## Reading entries with PIL

You can easily read these PNG chunks with PIL (Python Image Library)

```py
from PIL import Image

image = Image.open('myimage.png');
for k, v image.text.items():
    print(f'{k}: {v}')
```