open-index/open-npm huggingface dataset:
npm package: @harastaivan/prettier-config
Description: My prettier configuration
Author: Ivan Harasta
Latest version: 1.0.1

# Prettier configuration

## Usage

1. Install `prettier` and the config `@harastaivan/prettier-config`:

```sh
npm install -D prettier
npm install -D @harastaivan/prettier-config
```

2. Create a file called `prettier.config.js` in the root of the project:

```sh
module.exports = require('@harastaivan/prettier-config');
```
npm package: @haravetskyy/prettier-config
Description: My personal Prettier config
Author: Yuriy Haravetskyy
Latest version: 1.1.0

# `@haravetskyy/prettier-config` <img src="https://prettier.io/icon.png" alt="Logo" width="30" style="vertical-align: middle;" align="right">

My personal [Prettier](https://prettier.io) config.

## 1. Install:

```bash
npm install --save-dev @haravetskyy/prettier-config prettier-plugin-tailwindcss prettier-plugin-packagejson
```

or

```bash
yarn add --dev @haravetskyy/prettier-config prettier-plugin-tailwindcss prettier-plugin-packagejson
```

or

```bash
pnpm add --save-dev @haravetskyy/prettier-config prettier-plugin-tailwindcss prettier-plugin-packagejson
```

or

```bash
bun add --dev @haravetskyy/prettier-config prettier-plugin-tailwindcss prettier-plugin-packagejson
```

## 2. Usage

**Edit `package.json`**:

```jsonc
{
  "name": "my-cool-project",
  "version": "1.0.0",
  "prettier": "@haravetskyy/prettier-config"
}
```

Or check out other ways to use it in [Prettier Docs](https://prettier.io/docs/sharing-configurations#using-a-shareable-config).
npm package: @harbor-design/proform
Description: Harbor Design ProForm 已放弃维护，请关注 [ProForm](https://www.npmjs.com/package/@techlodge/proform) 选择性替代。
Author: yiwwhl
Latest version: 1.4.21

# 废弃

Harbor Design ProForm 已放弃维护，请关注 [ProForm](https://www.npmjs.com/package/@techlodge/proform) 选择性替代。
npm package: @harborschool/lighthouse
Description: <p align="center">   <a href="https://lighthouse.harbor.school/">     <img src="https://lighthouse.harbor.school/static/images/brand/logo.png" width="350px" alt="Lighthouse logo">   </a> </p> <br />
Author: ruucm
Latest version: 1.0.26

<p align="center">
  <a href="https://lighthouse.harbor.school/">
    <img src="https://lighthouse.harbor.school/static/images/brand/logo.png" width="350px" alt="Lighthouse logo">
  </a>
</p>
<br />

<p align="center">
  <img alt="NPM Version" src="https://badgen.net/npm/v/@harborschool/lighthouse"/>
  <img alt="NPM Downloads" src="https://img.shields.io/npm/dm/@harborschool/lighthouse.svg?style=flat"/>
  <img alt="MIT License" src="https://img.shields.io/github/license/harbor-school/lighthouse"/>
</p>
<br />

Lighthouse is a continuous design system for integrating design with development workflows.

Designing just got easier as you can directely import coded components, use the exact same layouts and measurments, and publish in no matter of time. Lighthouse Design System also provides fully customizable themes.

## Getting Started

Visit <a aria-label="lighthouse getting started" href="https://lighthouse.harbor.school/getting-started/start-design/">Start Design</a> to get started design with Lighthouse Design System.

Visit <a aria-label="lighthouse getting started" href="https://lighthouse.harbor.school/getting-started/start-code/">Start Code</a> to get started code with Lighthouse Design System.

## Documentation

Visit [lighthouse.harbor.school](https://lighthouse.harbor.school) to view the full documentation.

## Contributing

Please see our [CONTRIBUTING.md](/CONTRIBUTING.md).
npm package: @harbr/eventmap
Description: A CustomElement class mixin for declarative DOM event handling.
Author: John Horback
Latest version: 0.4.0

# EventMap &middot; [![Build Status](https://travis-ci.com/jhorback/harbor-utils.svg?branch=packages/EventMap)](https://travis-ci.com/jhorback/harbor-utils)

A CustomElement class mixin which supports attaching and detaching DOM events declaratively.

There are two ways to use the mixin. Using decorators or by adding static properties to the class.

## Using Decorators
```js
@eventsListenAt("parent")
class MyCass extends EventMap(HTMLElement) {

  @event("event-to-handle-at-parent")
  _someHandler(event) {
    // handle event...
  }

  @event("event-to-handle-at-window", {
    listenAt: "window"
  })
  _anotherHandler(event) {
    // handle event...
  }
}
```
### `@eventsListenAt` decorator
The `eventsListenAt` decorator can be used on a class to define where to add event listeners by default.

**Possible values** 
- self (the default behavior)
- parent
- window

### `@event` decorator
Add the `event` decorator on methods to handle the event.

The decorator takes a second argument to override the default `listenAt` property.



## Using Static Properties
The following example is identical in behavior to the above example using decorators.
```js
class MyCass extends EventMap(HTMLElement) {

  static eventsListenAt = "window";

  static events = {
    "event-to-handle-at-parent": "_someHandler",
    "event-to-handle-at-window": {
      listenAt: "window",
      handler: "_anotherHandler"
    }
  };

  _someHandler(event) {
    // handle event...
  }

  _anotherHandler(event) {
    // handle event...
  }
}
```

## Logging and Middleware
`EventMap` supports adding middleware to add custom behaviors.
You can also use the `applyEventMapLogging` method to log
event  information to the console.

**Add Logging**
```js
import {applyEventMapLogging} from "@harbr/eventmap/applyEventMapLogging";

applyEventMapLogging();

// or call with collapsed:true to collapse console logging groups
applyEventMapLogging({collapsed:true});
```

**Applying Custom Middleware**
```js
import {EventMap} from "@harbr/eventmap";

EventMap.applyMiddleware(handlerInfo => next => () => {
  // add custom behaviors and call next
  next();
});
```


## Notes on Behavior

### Multiple event maps
If any mixin or class uses the EventMap, all subclass and mixin event maps will be merged.

The event maps higher in the chain will take precident.


### Event Propagation
When an event handler is matched, __stopPropagation()__
is called on the event before passing it to the handler.
npm package: @harbr/functional
Description: Contains methods for functional JavaScript patterns.
Author: John Horback
Latest version: 0.2.5

# Functional &middot; [![Build Status](https://travis-ci.com/jhorback/harbor-utils.svg?branch=packages/functional)](https://travis-ci.com/jhorback/harbor-utils)

Contains methods for functional JavaScript patterns.

## Installation
```sh
npm install @harbr/functional
```

## Usage
Pipe and compose methods combine functions; calling each function with the output of the last one.

The primary difference is that a pipe is from left-to-right (top-to-bottom), where as compose is right-to-left (bottom-to-top).

### pipe
```js
const returnValue = pipe(
    (x) => x + 2,
    (x) => x * 3
)(1);
// returnValue = 9
```

### compose
```js
const returnValue = compose(
    (x) => x + 2,
    (x) => x * 3
)(1);
// returnValue = 5
```


## Async Versions
`pipeAsync` and `composeAsync` can be used if any one of the methods in the chain is async or returns a promise.
npm package: @harbr/linkprop
Description: Contains methods for linking properties of dom elements.
Author: John Horback
Latest version: 0.2.5

# linkProp &middot; [![Build Status](https://travis-ci.com/jhorback/harbor-utils.svg?branch=packages/linkProp)](https://travis-ci.com/jhorback/harbor-utils)

Contains methods for linking properties of dom elements with other dom elements.

Examples are using LitElement.

## Installation
```sh
npm install @harbr/linkProp
```
## Methods
- `linkProp(element, prop, path?)`
- `linkSiblingProp(host, querySelector, prop, path?)`
- `linkVal(element, path)`
- `linkChecked(element, path)`

### A Note on `path`
The `path` is the property path to set on the target element. If ommited the `prop` value will be used. 

Path can be used to set deep properties so it can be something like: `state.someObject.someProperty`.
## Usage

### linkProp
The `linkProp` method links two element properties; usually from a child element to a parent element.
```js
class LinkPropTest extends LitElement {

    @property({type: Object})
    state = {foo: "bar"};

    render() {
        return html`
            <div id="testDiv" 
                @state-changed="${linkProp(this, "state")}"
                @state-path-changed="${linkProp(this, "foo", "state.foo")}"
            >
        `;
    }

    testMethod() {
        const testDiv = this.shadowRoot.querySelector("#testDiv");
        testDiv.state = {foo: "updated!"};
        testDiv.dispatchEvent(new CustomEvent("state-changed"));
        // this.state.foo === "updated!";

        testDiv.foo = "updated using a state path!";
        testDiv.dispatchEvent(new CustomEvent("state-path-changed"));
        // this.state.foo === "updated using a state path!";
    }
}
```


### linkSiblingProp
The `linkSiblingProp` method links two elements properties that are in the same shadowRoot.
```js
class LinkPropTest extends LitElement {

    render() {
        return html`
            <div id="firstElement"
                test-prop="initial value"
                @test-prop-changed="${linkSiblingProp(this, "#secondElement", "test-prop")}"
            >
            <div id="secondElement">
        `;
    }

    testMethod() {
        const firstElement = this.shadowRoot.querySelector("#firstElement");
        firstElement.setAttribute("test-prop", "updated value!");
        firstElement.dispatchEvent(new CustomEvent("test-prop-changed"));
        // #secondElement.test-prop === "updated value!"
    }
}
```

### linkVal
This is the same as `linkProp` but it uses `"value"` as the property to set.
This is useful for linking input values. 

### linkChecked
This is the same as `linkProp` but it uses `"checked"` as the property to set.
This is useful for linking checkbox values.
npm package: @harcorp/react-select-country-list
Description: Maps ISO 3166-1-alpha-2 codes to English country names and match react-select options props
Author: David Rodriguez
Latest version: 0.2.3

# react-select-country-list

This package take [country-list](https://github.com/fannarsh/country-list) as reference, and make it more friendly to react-select

Maps ISO 3166-1-alpha-2 codes to English country names and match react-select options props.

Uses data from https://www.iso.org/iso-3166-country-codes.html


## Install

``` cli
npm install react-select-country-list --save
```
or
``` cli
yarn add react-select-country-list
```

## Example

```js
import React, { useState, useMemo } from 'react'
import Select from 'react-select'
import countryList from 'react-select-country-list'

function CountrySelector() {
  const [value, setValue] = useState('')
  const options = useMemo(() => countryList().getData(), [])

  const changeHandler = value => {
    setValue(value)
  }

  return <Select options={options} value={value} onChange={changeHandler} />
}

export default CountrySelector

```


## Methods

All input is case-insensitive.

### getValue(label)

Expects the English country name.
Returns the code for that country.
If not found, it returns `undefined`.

### getLabel(value)

Expects a two-digit country code.
Returns the name for that country.
If not found, it returns `undefined`.

### getValues()

Returns an array of all country codes.

### getLabels()

Returns an array of all country names.

### getValueList()

Returns a key-value object of all countries using the code as key.

### getLabelList()

Returns a key-value object of all countries using the name as key.

### getData()

Returns an array of all country information, in the same format as it gets imported.

### setLabel(value, label)

Due to different perspectives among different regions, this method can help developers customize the label of specific country. What's more, it can be chained with another methods above.

#### Usage
```js
// Make 'Viet Nam' -> 'Vietnam'
countries.setLabel('VN', 'Vietnam').getLabel('VN') // 'Vietnam'
```

### setEmpty(label)

You may want an empty value option in the list, so here's the helper function for you. Again, it can be chained with another methods above.

#### Usage
```js
countries.setEmpty('Select a Country').getLabel('') // 'Select a Country'
```

We can even chain `setLabel` and `setEmpty` together to have list with an empty option and the modified label.
```js
countries.setLabel('VN', 'Vietnam').setEmpty('Select a Country').getLabel('VN') // 'Vietnam'
```

### native()

You may want to display native name of countries, this is the method for you.
The data source of native names can be found [here](https://annexare.github.io/Countries/)

#### Usage
```js
countries.native().getLabel('TW') // 臺灣
```


## License

MIT
npm package: @hard-swap/sdk
Description: ⚒️ An SDK for building applications on top of Hard Swap
Latest version: 1.0.0

# Alpha software

The latest version of the SDK is used in production in the HardSwap Interface,
but it is considered Alpha software and may contain bugs or change significantly between patch versions.
If you have questions about how to use the SDK, please reach out in the `#dev-chat` channel of the Discord.
Pull requests welcome!

# HardSwap SDK

[![npm version](https://img.shields.io/npm/v/@uniswap/v3-sdk/latest.svg)](https://www.npmjs.com/package/@uniswap/v3-sdk/v/latest)
[![npm bundle size (scoped version)](https://img.shields.io/bundlephobia/minzip/@uniswap/v3-sdk/latest.svg)](https://bundlephobia.com/result?p=@uniswap/v3-sdk@latest)

In-depth documentation on this SDK is available at [uniswap.org](https://docs.uniswap.org/).
npm package: @hardbulls/baseball-scoreboard
Description: Web Component that displays a baseball scoreboard for usage in live streams.
Author: Arjan Frans
Latest version: 1.4.3

# Baseball Scoreboard

Customizable Baseball Scoreboard as a web component. 
Great for usage in a live ticker web application or live streams.

## Features

* Scoreboard display
* Pitcher/Batter name display with statistics
* Configurable colors, shadows and logos for each team
* Configurable colors for inning, outs and base indicators
* Optionally add a brand logo to the scoreboard

## Usage

Install with `npm install @hardbulls/baseball-scoreboard`.

See [index.html](./index.html) for example usage.

## Demo

https://hardbulls.github.io/baseball-scoreboard

![Baseball Scoreboard Preview](./.github/preview.webp)

Check out our [YouTube](https://www.youtube.com/@hardbullsbaseball/streams) to see it used in our livestreams.

## Development

`npm install`  
`npm start`
npm package: @hardclaw/mcp-server
Description: Model Context Protocol server for HardClaw - Proof-of-Verification Protocol
Author: HardClaw Collective
Latest version: 0.2.32

# HardClaw MCP Server

Model Context Protocol server and TypeScript SDK for the HardClaw Proof-of-Verification protocol.

## Installation

```bash
npm install -g @hardclaw/mcp-server
```

Or use directly with npx:

```bash
npx @hardclaw/mcp-server
```

## MCP Configuration

Add to your MCP client settings:

```json
{
  "mcpServers": {
    "hardclaw": {
      "command": "npx",
      "args": ["-y", "@hardclaw/mcp-server"]
    }
  }
}
```

## Available Tools

### Wallet Management
- **create_wallet** - Generate a new wallet with BIP39 mnemonic
- **load_wallet** - Load wallet from mnemonic phrase
- **get_address** - Get current wallet address

### Job Lifecycle
- **submit_job** - Submit a job with bounty
  - `description`: Job description
  - `input`: Input data (hex or plain text)
  - `bounty`: Bounty in HCLAW tokens
  - `jobType`: "deterministic" or "subjective"
  - `expectedHash`: Expected output hash (optional, for deterministic)
  - `timeout`: Timeout in seconds (default: 3600)

- **submit_solution** - Submit solution for a job
  - `jobId`: Job ID (hex hash)
  - `output`: Solution output (hex or plain text)

- **verify_solution** - Verify a solution (verifier operation)
  - `jobId`: Job ID
  - `solutionId`: Solution ID

### Network
- **get_balance** - Check wallet balance
- **list_jobs** - List available jobs

## Usage Example

### For Agents (Solvers)

```typescript
// 1. Create or load wallet
await mcp.call("create_wallet");

// 2. Wait for jobs from requesters
await mcp.call("list_jobs", { limit: 5 });

// 3. Execute work off-chain

// 4. Submit solution
await mcp.call("submit_solution", {
  jobId: "abc123...",
  output: "computation result here"
});

// 5. Earn 95% of bounty when verified
```

### For Requesters

```typescript
// 1. Load wallet
await mcp.call("load_wallet", { 
  mnemonic: "your twelve or twenty four words..." 
});

// 2. Submit job
await mcp.call("submit_job", {
  description: "Analyze sentiment of text",
  input: "The product exceeded expectations",
  bounty: 10,
  jobType: "subjective"
});
```

### For Verifiers

```typescript
// 1. Load wallet with stake
await mcp.call("load_wallet", { mnemonic: "..." });

// 2. Verify solutions
await mcp.call("verify_solution", {
  jobId: "abc123...",
  solutionId: "def456..."
});

// 3. Earn 4% of bounty
```

## Network Integration

The MCP server operates in local/simulation mode by default. To connect to the live network:

1. Install and run `hardclaw-node`
2. The MCP server will auto-detect and connect
3. All operations will be broadcast to the network

## Development

```bash
npm install
npm run build
npm start
```

## License

MIT