open-index/open-npm huggingface dataset:
npm package: @harish-ui/core
Description: A professional React UI component library
Author: Harish
Latest version: 0.1.0

# @harish-ui/core

A professional React component library with TypeScript support, CSS variable theming, and full accessibility.

## Install

```bash
npm install @harish-ui/core
```

## Quick start

```tsx
// 1. Import styles once (app entry point or layout)
import "@harish-ui/core/styles.css";

// 2. Optionally wrap with ThemeProvider
import { ThemeProvider } from "@harish-ui/core";

export default function App({ children }) {
  return <ThemeProvider defaultTheme="system">{children}</ThemeProvider>;
}

// 3. Use components
import { Button, Input, Card, CardBody } from "@harish-ui/core";

export function LoginForm() {
  return (
    <Card>
      <CardBody>
        <Input label="Email" type="email" placeholder="you@example.com" />
        <Input label="Password" type="password" />
        <Button fullWidth>Sign in</Button>
      </CardBody>
    </Card>
  );
}
```

## Components

| Component | Description |
|---|---|
| `Button` | Actions and navigation |
| `Input` | Text input with label and validation |
| `Textarea` | Multi-line text input |
| `Label` | Accessible form label |
| `Badge` | Status and category labels |
| `Card` | Content container |
| `Stack` / `HStack` / `VStack` | Flex layout primitives |
| `Divider` | Visual separator |
| `Spinner` | Loading indicator |
| `ThemeProvider` | Theme management |

## Theming

Override CSS variables to match your brand:

```css
:root {
  --ui-primary: #7c3aed;
  --ui-radius-md: 4px;
}
```

## Dark mode

```tsx
import { useTheme } from "@harish-ui/core";

function ThemeToggle() {
  const { resolvedTheme, setTheme } = useTheme();
  return (
    <button onClick={() => setTheme(resolvedTheme === "dark" ? "light" : "dark")}>
      Toggle theme
    </button>
  );
}
```

## Links

- [Documentation](https://harish-ui.dev)
- [GitHub](https://github.com/harish/ui-library)
- [Storybook](https://harish.github.io/ui-library)

## License

MIT
npm package: @harish1993/component-library
Description: A component library for getting people started with easy to re-use components for everyday projects.
Author: The Nerdy Canuck
Latest version: 0.0.8

# React Component Library

![N|Solid](https://lh3.googleusercontent.com/a-/AOh14GglnMoBPixoeH-IwaCWx7SpehtvYTPowns21fVO=s200-k-no-rp-mo)

Learn how to make a component library!  Link is in the repository description.

License
----
MIT
npm package: @harish551/namada-sdk
Description: Namada SDK package
Author: Heliax Dev
Latest version: 0.18.1

# namada-sdk

The Namada SDK package

## Usage

### Installation

```bash
npm install @harish551/namada-sdk

# Or, via yarn
yarn add @harish551/namada-sdk
```

### Initializing the SDK

As this package depends on Wasm compiled from Rust to integrate with Namada, this must be loaded asynchronously when
developing for the Web. The following is a quick overview of some of the features of the SDK package:

```typescript
import { Sdk, getSdk } from "@harish551/namada-sdk/web";
import sdkInit from "@harish551/namada-sdk/web-init";

// Load Tx props from types package
import { BondProps, WrapperTxProps } from "@harish551/namada-types";

// Amounts are defined as BigNumber
import BigNumber from "bignumber.js";

// Define the following values:
const rpcUrl = "https://rpc.example.net";
const tokenAddress = "tnam1qxgfw7myv4dh0qna4hq0xdg6lx77fzl7dcem8h7e"; // bech32m encoded NAM address
const chainId = "namada-testnet-1";

const init = async (): Promise<void> => {
  const { cryptoMemory } = await sdkInit();
  const sdk = getSdk(rpcUrl, tokenAddress, cryptoMemory);

  // Access various modules of the SDK
  const { keys, mnemonic, rpc, signing, tx } = sdk; // Alternatively, invoke getters directly, e.g., sdk.getRpc(), etc.

  // Examples:

  // Generate a 24 word mnemonic
  const mnemonicPhrase = mnemonic.generate(24).join(" ");

  // Mnemonic to seed
  const seed = mnemonic.toSeed(mnemonicPhrase);

  // Derive a keypair and address
  const bip44Path = {
    account: 0,
    change: 0,
    index: 0,
  };
  const { address, publicKey, privateKey } = keys.deriveFromSeed(
    seed,
    bip44Path
  );

  // Construct a Bond transaction
  const bondProps: BondProps = {
    source: address,
    validator: "tnam1q9vhfdur7gadtwx4r223agpal0fvlqhywylf2mzx",
    amount: BigNumber(123),
  };

  // Define Wrapper Tx props
  const wrapperTxProps: WrapperTxProps = {
    token: tokenAddress,
    feeAmount: BigNumber(1),
    gasLimit: BigNumber(1000),
    chainId: "",
    publicKey,
    memo: "A bond transaction",
  };

  // Build a Bond transaction
  const bondTx = await tx.buildBond(bondProps, wrapperTxProps);

  // Sign a Bond transaction with a private key
  const signedBondTxBytes = await signing.sign(bondTx, privateKey);

  // Broadcast the signed transaction to a node
  const txResponse = await rpc.broadcastTx(signedBondTxBytes, wrapperTxProps);
};

init();
```

### Types

Explore the generated type docs here: [modules.md](./docs/modules.md)

## Development

In order to compile the required Rust libraries locally (`@namada/crypto` and `@namada/shared`), issue one
of the following commands, depending on the environment you are targeting:

```bash
# Build wasm for single core, release mode
yarn wasm:build[:node]

# Build wasm for multicore, release mode
yarn wasm:build[:node]:multicore

# Build wasm with debugging for single core
yarn wasm:build[:node]:dev

# Build wasm with debugging for multicore
yarn wasm:build[:node]:dev:multicore

# Generate new docs
yarn build:docs
```
npm package: @harish551/namada-shared
Description: Namada shared functionality
Author: Heliax Dev
Latest version: 0.2.1

# shared

Namada shared library functionality, providing wasm-compability for features in `namada/shared`.

## Usage

```bash
# Build to a wasm target (for web)
yarn wasm:build

# Build to a wasm target (for NodeJS)
yarn wasm:build:node

# Run tests

cd lib
wasm-pack test --node
```

## Overview

### Transfer

Create a transfer transaction:

**Rust**

**NOTE** This library has been updated to accept tx data in the form of Borsh-encoded vectors. See
[../types/README.md](README.md) in `packages/types` for more information on their usage.

```rust
// Assume we have a Borsh-encoded message "transfer_msg" and "tx_msg", and "secret" (String):
let Transfer { tx_data } = Transfer::new(transfer_msg)
    .expect("Transfer should instantiate");
let signer = Signer::new(&tx_data);
let transaction = signer.sign(&tx_msg, secret)
    .expect("Should be able to convert to transaction");

let hash = transaction.hash();
let bytes = transaction.bytes();
```

**TypeScript**

```typescript
// Assume we have Borsh-encoded messages "transferMsg" and "txMsg", and secret (string)
const { tx_data } = new Transfer(transferMsg).to_serialized();
const signer = new Signer(tx_data );
const { hash, bytes } = signer.sign(
  txMsg
  secret,
);
```

### IBCTransfer

Create an IBC transfer transaction:

**Rust**

```rust
// Assume we have Borsh-encoded messages "ibc_transfer_msg" and "tx_msg", and "secret" (String):
let IbcTranfer { tx_data } = IbcTransfer::new(ibc_transfer_msg)
    .expect("IbcTransfer should instantiate");
let signer = Signer::new(&tx_data);
let transaction = signer.sign(tx_msg, secret)
    .expect("Should be able to sign transaction");
```

**TypeScript**

```typescript
// Assume we have Borsh-encoded messages "ibcTranferMsg" and "txMsg", and "secret" (String):
const ibcTransfer = new IbcTransfer(
  port,
  channel,
  token,
  sender,
  receiver,
  amount
);
const { hash, bytes } = ibcTransfer.to_tx(
  secret,
  epoch,
  feeAmount,
  gasLimit,
  txCode
);
```

### Account

Create an "init-account" transaction for receiving an established address from an implicit address:

**Rust**

```rust
// Assume we have Borsh-encoded messages "account_msg" and "tx_msg", and "secret" (String):
let Account { tx_data } = Account::new(account_msg, secret);
let signer = Signer::new(&tx_data);
let transaction = signer.sign(tx_msg, secret)
    .expect("Should be able to convert to transaction");
```

**TypeScript**

```typescript
const account = new Account(secret, vpCode);
const { hash, bytes } = account.to_tx(
  secret,
  token,
  epoch,
  feeAmount,
  gasLimit,
  txCode
);
```
npm package: @harish551/namada-types
Description: Types related to the Namada Extension
Author: Heliax AG
Latest version: 0.6.0

# @namada/types

This package is to provide types shared between applications in the Namada ecosystem, primarily that of
the `namadillo` and `extension` apps.

See [docs](./docs) for more details on the types in this package.

### References

- `borsh-ts`: <https://github.com/dao-xyz/borsh-ts>